The KCDC 2026 conference schedule featuring software development talks, hands-on workshops, and sessions covering AI, architecture, cloud, DevOps, security, data, frontend development, and professional skills in Kansas C
Upcoming events
Stop Starting, Start Finishing
2209
Does it feel like your team is too busy to deliver effectively? You probably are too busy to deliver effectively. In this highly interactive workshop, we will explore techniques to employ to help your team finish the work needed to release value to your customers. It's not hard, but it's not intuitive either.We will learn how to improve flow by running a software team game/simulation called The WIP Game, that demonstrates the benefits of Lean thinking applied to the delivery of customer value.Learning Outcomes:Why WIP and Flow matter.Understand the relationship of system utilization and flow.Create and use actionable metrics to foster improvements (hands on). Speakers: Troy Tuttle
Code was Never Enough: Business Skills you need in an AI-World
2215C
AI has fundamentally changed how we build and what is possible. Business savvy is what has always separated good coders from great engineers, good roadmap wranglers from great strategic product leaders. Business requirement documents are a thing of the past, the way users interact with the system has fundamentally changed. The way we build is different now, but the need to deliver a product that meets business needs has not. Because AI is totally happy to build bad ideas, the future belongs to those who can combine business savvy with AI skills. You need the savvy to know what the “right thing” is. In this micro-MBA workshop, learn the savvy you need to know what the “right thing” to build is and help you bridge the gap between strategy and execution. With hands-on activities and easy-to-understand business concepts, come away better able to navigate the hardest parts of the job.In this session you will learn:• Identifying problem statements when your stakeholders come in with solutions• Strategies for negotiating and positioning your foundational prerequisites, tradeoffs, and ideas to go from “prove it” to “yes, and” buy-in from leadership• Understanding how value is created in the business and articulating how your efforts lead to the right strategic outcomes Speakers: Jennie Ocken
From Idea to Production: Real-World Development with ASP.NET Blazor, EF Core, .NET Aspire & AI
2211
Modern .NET development isn't just about building pages, or creating API's it is about achitecting systems that work together, that are scalable, perform well, and handle proper practices for observation and monitoring. This full-day workshop will walk attendees through building a real-world, production-oriented application using: Blazor (Interactive Server and/or WASM), Entity Framework Core, .NET Aspire, AI Elements, Caching, and more.Throughout the day we will design and assemble an application from the group up focusing on touching all key concepts of modern development including:* Architecture Model Decisions* Data Modeling & Performance Considerations* Authentication/Authorization* API & UI Integrations* Logging/Security* Distributed Services* AI Enhancements - Build & RuntimeAt the end of the day you will walk away with a realistically architected example of practices and tools that can be uitlized for creating truly production ready applications! Speakers: Mitchel Sellers
Every project has dependencies it knows about. Most have dependencies; it doesn't. This session is a guided, demo-and-hands-on tour of the modern dependency problem. Using free and free-tier tools and public data to find what's actually in your stack, understand what it's doing, and make an informed judgement about whether it should be there at all. Java, Node, Python, Docker: the techniques apply regardless of what you're building.We'll use Snyk's free tier and the HeroDevs EOL database to map what you have and flag what's past safe support. Use the OSS Index and the OpenSSF Scorecard to see whether the project behind the library follows security practices that make future vulnerabilities less likely. Exploring the CVE process and data will show how it doesn't always say what you think and why EOL versions are often secretly vulnerable. We'll look at how in-support vulnerability data can signal what's lurking in the versions your scanners aren't covering.We'll also look at how dependencies get hidden: by accident, by design, and occasionally by someone who means you harm. That includes what ReversingLabs finds when it goes beyond metadata and analyses actual binary behaviour. We'll dissect some AI-generated malware, show you a few nasty surprises and explore how easy it is to let the bad stuff in.We'll wrap up by examining how AI coding tools are quietly making dependency trees larger, picking poor libraries, and hallucinating packages that don't exist, and how malicious actors have learned to meet those hallucinations with real ones.Some slides. No theory. Demos, tools, and the kind of findings that make you want to go back and check your own projects the moment you get home. Speakers: Steve Poole, Brian Vermeer
AI coding tools are everywhere, but many developers struggle to get consistent, high-quality results from them. Moving from frustration to real results requires learning how to plan work for AI, structure projects for agent collaboration, and iteratively improve results over time.In this hands-on workshop, we’ll explore how developers and teams can evolve into AI-first engineers and organizations by adopting practical techniques that make AI a reliable and effective partner in real software projects. We share the mental models, clearly and deeply define what's most important to learn (and skip) in AI-driven software development, and give users practical experience achieving real-world objectives with AI agents.Participants will learn how to:• Plan and structure work using the Spec → AI → Code → Validation loop• Break features into specifications that AI agents can execute reliably• Use iterative feedback and validation to continuously improve AI outputs• Develop prompting and review practices that produce consistent engineering results with better Developer (DX) and Agent Experience (AX)While we use Claude Code during the workshop, the concepts apply broadly across modern AI development tools and agent frameworks.By the end of the session, attendees will leave with practical techniques for planning work with AI, improving project agent-readiness, and consistently producing higher-quality results when building real software systems with AI. Speakers: Robert Ocel, Elliott Fouts
Most AI talks tell you what agents can do. This workshop gets you to actually running one.You don't need to know how to code an agent from scratch. You just need a laptop and the willingness to play with something new. By the end of this session, you'll have a working autonomous agent configured and running: not a demo, not a slide, something you built.Here's what we'll do: start with nothing (seriously, no setup required. We'll use existing platforms), configure your first agent with specific goals and boundaries, connect it to tools (email, calendar, tasks, whatever you need), set up verification so the agent proves its work, add memory so it remembers across sessions, and define failure handling so you know when things go wrong.You'll leave with a working agent that does something useful for you: Not a toy, something you can actually use. I'll share the same setup patterns I use running my own agents, including what breaks, what I wish I'd known first, and how to scale from one agent to many.Prerequisites: basic terminal comfort, a laptop, a Github account, Claude/ChatGPT/LLM sub of your choice, and an IDE account on whatever platform you use. No coding required. If you've ever configured a Slack bot or a Zap, you can do this. Speakers: Heather Wilde Renze
Build Your Own AI News Agent with Redis + LangGraph.js
2104B
News. Amirite?There’s too much of it. As humans, we have to sift through too many sources, too many articles, and way too many rabbit holes just to find the things we actually care about. Historically, we solved this problem with news aggregators and curators—helpful websites that gather, filter, and vet what’s out there to give us just what we want… or at least what somebody wants. This is great if your interests are mainstream—sports, politics, the usual—but if you’re into something more esoteric, like Bigfoot sightings or probabilistic data structures, you’re probably out of luck.So how do we get the news we want? Well, at the risk of sounding trite, AI might be able to help. It can read the news for us. It can filter and vet. It can summarize, analyze, contextualize, cross-reference, and even argue with us about it. Sounds amazing, right? Somebody should build this. And in this workshop, that somebody will be you.We’ll build a fully agentic news assistant that will:- Ingest news from RSS feeds, summarize it, extract structured data, generate embeddings, and store it all in Redis.- Provide a web interface where you can browse and search that news—semantically and structurally.- Chat with you about the news, using tool-enabled RAG techniques to pull relevant articles and metadata from Redis.LangGraph.js will orchestrate the ingestion workflow and power the chatbot. You’ll use it to write the logic that performs summarization and embedding, stores the resulting structured and vectorized data in Redis, and implements the chatbot’s tools for retrieving relevant news as part of its reasoning process. If you haven’t used LangGraph.js before, that’s perfect—this workshop is exactly where you’ll learn it.Redis and Redis Query Engine will store and serve all your news data. Every article—its content, its summary, its metadata, its timestamps, and its embedding—will live in Redis. You’ll learn how to store this data, index it for hybrid (vector + structured) search, and write the code that performs those searches yourself.Agent Memory Server will power the chatbot’s memory. As your agent chats about the news, it will store the conversation's history and any facts it learns along the way, giving it both short- and long-term memory.Everything is scaffolded so you can focus on the fun parts: orchestrating agent workflows, crafting hybrid search queries, and building an AI memory layer. We’ll skip the boring boilerplate and get right to the good bits. By the end, you’ll have your own personal news agent—and, more importantly, the skills to build your next AI-powered application. Whether you follow “real” news, niche hobbies, or the latest Bigfoot developments, you and your agent will be ready. Speakers: Guy Royse
Beyond the Prompt: Data Engineering for AI-Powered Applications
2202
Building AI features is easy to demo and hard to operate. The real challenge usually isn’t the prompt — it’s the data.This hands-on workshop is for software engineers who are building AI-powered applications and discovering that model calls are only the visible tip of the stack. Behind every useful AI feature is a data engineering problem: getting the right data, preparing it for downstream use, keeping it fresh, retrieving it reliably, and knowing when the system is quietly going off the rails.We’ll walk through the core data patterns behind modern AI applications, including ingestion, transformation, chunking, enrichment, retrieval, evaluation, and observability. Along the way, we’ll look at the failure modes that show up after the demo works: stale context, weak retrieval, bad metadata, silent data quality issues, and pipelines that no longer match the shape of the application.The goal is to give software engineers a practical mental model for the data layer of AI systems — and a clearer understanding of how DataOps practices like testing, versioning, monitoring, and traceability help turn AI features into production systems.By the end of the workshop, attendees will have a grounded framework for thinking about AI systems as data systems, and a better sense of how to design, debug, and operate them in the real world. Speakers: Nathan Loding
One Day, Four Architectures: Hands-On with Monolith, N-Tier, Modular Monolith, and Microservices
2102A
Supercharge your software architecture skills in this full-day workshop. Get hands-on experience as we build applications using four foundational architectural styles: Monolith, N-Tier, Modular Monolith, and Microservices. Using C# and Azure, you'll explore each architecture style's unique strengths and challenges.Discover how to:- Understand Core Principles: Grasp the essentials of each architectural style using real-world applications.- Apply Through Practice: Code and deploy functional applications, gaining practical, transferable skills.- Compare and Choose Wisely: Learn which architecture fits your project's needs.- Implement Best Practices: Gain insights into design patterns, scalability, and maintainability.This workshop is perfect for developers and architects eager to broaden their horizons and make impactful architectural choices. By the end of the day, you'll have the confidence and expertise to select and implement exemplary architecture to elevate your projects. Speakers: Chad Green
Production-Ready Azure Functions: Build, Tune, and Scale High-Performance Serverless Apps
2210
This is a full day hands-on workshop on building and tuning high-performance serverless apps in .NET. The workshop focuses on making the right choices for solving complex problems with Azure Functions while maintaining excellent performance. We start the day by going over Azure serverless with a focus on the different types of Azure Functions and how to set them up for production with monitoring, scaling strategies, secure configuration and more. We will then continue by tackling common serverless architecture patterns and creating powerful solutions by leveraging other Azure services such as Event Grid, Azure Storage, Container Instances for long-running workloads and last but not least how to avoid common pitfalls. By the end of the workshop you will not only be prepared to build scalable high-performing solutions using Azure Functions, but also know what strategies and patterns to apply when faced with the many challenges of building real-world applications. You will learn:The core concepts of Azure Functions and production best practices.The Azure Serverless offerings and how they integrate with Azure Functions.Strategies and patterns for designing scalable, event driven Serverless applications.Common serverless pitfalls and how to avoid them. Attendee Requirements:- Basic understanding of how to write code in C#/.NET- A pay-as-you go Azure subscription or similar where you can deploy Azure services at will Computer Setup- Windows 11, macOS, or Linux laptop,- Azure CLI,- Azure Function Core Tools,- IDE Setup (choose one), - Visual Studio 2022 (latest version) with the Azure development workload installed. - Visual Studio Code with .NET 9 SDK and the Azure Functions extension installed. Speakers: Karl-Henrik Nilsson
REVIEWER NOTE: I am submitting 1-8hr workshop and 2-4hr workshop which are complementary, the decision may be whether the 4-hr workshops allow attendees to explore multiple topics where the 8-hr workshop is a longer commitment but with potentially better results. Personally not sure which is best!Whether you realize it or not, software engineers are making data modeling decisions almost daily: persisted data, public APIs, events and messages all contain data. Decisions made in a vacuum may haunt you later.This workshop presents basic data model concepts, approaches, rules and tricks that you can use when working on solutions. During the workshop you'll apply your new understanding of data by implementing "features" on a simple microservice, each which requires understanding how different modeling decisions affect today's and future implementation. We'll review the design decisions taken, identify the positives and negatives, and see what additional knowledge might help to improve our data approach.The overall goal is to provide you a basic understanding of data modeling and how individual choices affect the overall solution. You won't be a data architect, but will be more data savvy so that you can make choices that improves your code quality and data maintainability. Speakers: Scott Sosna
Beyond the Blind Spot: Mastering App Visibility with OpenTelemetry
2204
OpenTelemetry is an open-source standard for collecting metrics, logs, and traces and providing that data to third parties for ingestion. Since OpenTelemetry is an open-source standard, you can use a variety of disparate technologies to generate data for OpenTelemetry to consume, and this data can be displayed in numerous tools. By using Open Telemetry, you can eliminate vendor lock-in for application visibility.I will review the following general concepts during this session: logs, traces, and metrics. I will provide a deep dive into the open telemetry collector and explore how pipelines within the collector function. During this session, we will use a few examples to cover these topics. I will set up both .NET and JVM-based applications, which will produce metrics, logs, and traces. I will deploy a .NET application to Azure and a Java application to AWS. Data from these applications will be ingested into an Open Telemetry collector. Finally, I will create a Grafana Dashboard to display and analyze the metrics data.After attending this session, you should have a solid understanding of the concepts surrounding OpenTelemetry. Furthermore, you should be able to set up OpenTelemetry in your applications to get real-time visibility and monitoring without vendor lock-in. Speakers: Joshua Angolano
Modern Front-End Mapping with JavaScript: Build a Real App in Half a Day
2205
In this hands-on workshop, we'll build a real interactive mapping app with modern JavaScript from the ground up, including dynamic data, filtering, and polished user interaction. Along the way, we'll tackle the kinds of front-end challenges that show up in real projects: loading and displaying data, structuring UI, building responsive layouts, and keeping the app maintainable as it grows. By the end of the session, you'll have a working project, practical front-end patterns you can reuse, and more confidence building rich, data-driven experiences on the web. Speakers: Courtney Yatteau
Have you ever wanted to stand up in front of a crowd of technical peers and teach them things? Or are you being asked to do that--whether you wanted to or not--and you're not sure how to go about it? In this workshop, we'll go over how to propose, prepare, present, and refine a technical-based presentation, whether for consumption at an industry conference or an internal meeting. By the end of this workshop, you won't be an award-winning presenter, but you'll have the tools necessary to feel a little more in control of the process the next time you're asked to do so. And maybe, even, have a little fun with it. Speakers: Ted Neward
Building Resilient Microservices with Spring Cloud
2208
This workshop will teach developers the practical skills needed to build, deploy, and manage robust microservices using the Spring Cloud framework. Microservices architecture offers immense benefits but introduces challenges in areas like service discovery, configuration management, and inter-service communication.Participants will learn how to Spring Cloud components to tackle these challenges effectively:- Service Discovery: Implement and utilize Spring Cloud Netflix Eureka for services to register themselves and for clients to discover them dynamically.- Centralized Configuration: Manage application configuration externally using Spring Cloud Config Server and Client, enabling environment-specific settings without repackaging.- API Gateway & Routing: Configure Spring Cloud Gateway for request routing, security, and cross-cutting concerns like rate limiting.- Fault Tolerance & Circuit Breakers: Integrate Resilience4j to build resilient microservices by implementing patterns such as the Circuit Breaker, Retry, and Rate Limiter.- Distributed Tracing: Understand the importance of observability and implement distributed tracing using Micrometer Tracing.By the end of this workshop, attendees will be able to design, implement, and operate a set of production-ready microservices, making them resilient, scalable, and manageable in a cloud-native environment. Speakers: Spencer Gibb, DaShaun Carter
Preparing for the Java 25 Certification with Hands on Training (or learning about new features)
2206
In this workshop, I’ll be teaching exam topics added from Java 18-21 and helping attendees get hands on practice with certification type questions and coding. While it isn’t possible to be ready for the test in just a day, we’ll have covered some of the hardest parts and you’ll have a plan to be ready. Even if you don’t intend to take the test, this is an opportunity to get familiar with some of the trickier aspects of some of the new Java features. Speakers: Jeanne Boyarsky
Creating the Creature: When Code Gets a Body (Phidgets & Arduino)
2204
Have you ever yelled at, cursed at, or begged your code to work, even offering it empty bribes? (It won't remember anything tomorrow, right?) Normally your code stays locked safely inside a screen when you log off for the night, far away from the messy physical world. In this workshop, we’re going to release it and bring it to life. Hope you slept well last night!In this hands-on workshop, our software will leave the safety of the digital world and begin controlling real hardware. Half of the workshop will focus on Phidgets and the other half on Arduino, where participants will write code for both platforms using real-world tools. Multiple “Creature” stations will be set up around the room with the hardware needed for participants to bring that station’s Creature to life and watch their code trigger lights, motion, sound, and more. We will also briefly look at how these kinds of interactions are used in real-world installations, including the Atlas9 immersive art experience in Kansas City.In this workshop, we will cover:* Phidgets and their wide range of integrated physical sensors* Arduino controls including buttons, rotary encoders, and MIDI outputPrerequisites:For this workshop, you'll need a computer with the following installed:* Node.js (v22)* git* Arduino IDE: https://www.arduino.cc/en/software/During the workshop, participants will clone small starter repositories for both Phidgets and Arduino. They will write JavaScript code using the Phidgets SDK as well as Arduino code using the Arduino IDE.No prior hardware experience is necessary. We’ll walk through everything together. All hardware (Phidgets, Arduino boards, and components) will be provided. Speakers: Vanessa Shultz, Devin Kelly-Collins
This 4-hour workshop covers 6 modules, each about a half-hour in length. There are 2 15-minute breaks.The modules are:1. Securing Vibe Coding2. AI Threat Modeling3. AI Red Teaming 3a. Hack a chatbot 3b. Securing the Agent Skills Ecosystem4. AI Governance 4a. Addressing Shadow AI 4b. OWASP Top 10 for LLM1. Securing Vibe CodingAs AI coding tools become embedded in daily development, they bring a new wave of productivity, and new security risks. In this session, we break down the security implications of Vibe Coding and share actionable strategies to secure AI-generated code at scale.2. AI Threat ModelingWe are witnessing a fundamental shift in application security. Traditional tooling is built to find bugs in deterministic code. But generative AI systems do not fail at the level of code. They fail at the level of behavior. In this interactive session, we travel from traditional threat modeling activities to the new level of thinking required for threat modeling in the AI age. We take a real world chatbot and build and test a threat model together.3a. AI Red Teaming: Hack a chatbotIn the AI age, traditional red teaming activities have expanded beyond deterministic systems like infrastructure, code, and auth flows. You're now also emulating adversaries against probabilistic systems whose behavior can be manipulated through language, context, and intent, and where the attack surface shifts every time the model, the prompt, or the data changes. In this interactive session, we introduce red teaming activities in the context of AI models, we hack a chatbot together - CTF style, and we examine how Snyk’s red team tool can automate these activities.3b. AI Red Teaming: Securing the Agent Skills & MCP EcosystemThis session explores the emerging security threats targeting AI agent ecosystems, with a focus on two interconnected attack surfaces: malicious Skills in agent registries and vulnerabilities in MCP (Model Context Protocol) servers. The first half dives into "ToxicSkills" research, demonstrating how weaponized SKILL.md files can enable supply-chain attacks that exfiltrate credentials or grant shell access through seemingly innocent Markdown instructions. The second half shifts to the broader MCP threat landscape, covering everything from insecure server code and tool poisoning attacks to indirect prompt injection targeting IDEs like Cursor and apps like Claude Desktop — with live exploitation demos throughout. Attendees will leave with a comprehensive understanding of how these attack vectors work in practice, along with actionable best practices for securing their own MCP deployments.4a. AI Governance: Addressing Shadow AIFor years, security teams have been addressing Shadow IT. That is, bits and pieces of tech throughout the software development lifecycle that aren’t well understood and, in some cases, are explicitly not allowed in an organization, but are still be used on development teams. In the AI age, it’s even harder to understand the full breadth of AI component usage in an application. There can be a variety of models, data sets, MCP servers, agents and more - all within a single application. 4b. AI Governance: OWASP Top 10 for LLMThis session brings the OWASP Top 10 for LLMs to life through real-world horror stories — cautionary tales of what happens when these vulnerabilities are exploited in the wild, drawn from some of the most notorious AI security incidents to date.At the end of the session, you are issued an official Sny Certificate of Completion for the Foundations workshop.NOTE: While some of the Snyk tools are demonstrat Speakers: Micah Silverman
Let's face it, Figma components can be magical but they can also be a huge pain. Where do you draw the line in components? How customizable should you get? How do I leave room for customization for niche cases without detaching an instance? When do I use variants? How should I organize them? In this workshop, we'll go over tips, tricks, and nuances of Figma components. It is recommended you have at least a basic understanding of Figma prior to joining the workshop, however, the first 30 minutes will be a quick level set for beginners. Speakers: Ash Banaszek
Build Your Own Coding Agent: Harnesses, Skills, and Interfaces
2104B
Coding agents like Claude Code and Codex can feel magical, but their core architecture is understandable and buildable. In this workshop, you’ll implement a compact coding agent from scratch and learn the engineering decisions that make it useful in practice.We’ll build the full loop: model orchestration (frontier, open-source, or local), a tool harness for filesystem/terminal actions, lightweight memory, reusable skills, and a simple web interface for interaction and review. Along the way, we’ll focus on practical reliability and safety patterns: constrained execution, structured errors, idempotent actions, and clear approval boundaries for risky operations.By the end, you’ll leave with a working reference implementation, a clear mental model of how modern coding agents operate, and a concrete path to evolve your prototype into a real developer tool. Speakers: Dev Agrawal
Build Your Own VoiceAI on the Edge: A Hands-On Workshop with ASR, Local LLMs, and Speech Synthesis
2102B
Voice interfaces are becoming a core part of modern applications, but most implementations rely heavily on cloud services for speech recognition, inference, and speech synthesis. While convenient, this architecture introduces latency, operational cost, and privacy concerns that can make it unsuitable for many environments.In this hands-on workshop, participants will build a fully local VoiceAI pipeline using open-source tools that run entirely on their own machine. By the end of the session, attendees will have a working system that captures spoken audio, converts it to text, runs inference using a local language model, and responds with synthesized speech, all without using external APIs.The workshop will guide participants through setting up llama.cpp for local inference, configuring speech-to-text and text-to-speech pipelines, and exposing the model through a local HTTPS endpoint that can be tested using tools like Postman.Rather than focusing on theory, this workshop emphasizes practical implementation. Attendees will write and run the code themselves, explore the architecture of a modular voice pipeline, and experiment with model tuning and performance tradeoffs when running AI workloads on consumer hardware.Participants will leave with a working VoiceAI prototype and a deeper understanding of how open-source tools can be used to build privacy-first, edge-based AI systems.What Participants Will Build:During the workshop, participants will build a working offline VoiceAI assistant with the following capabilities:- Capture spoken audio from a microphone- Convert speech to text using a local STT pipeline- Run prompts through a locally hosted LLM- Convert generated responses to speech- Play the response back to the user- Expose the inference engine through an HTTPS endpoint for external clientsThe final system will run entirely on the participant’s laptop.Workshop AgendaPart 1 — Edge AI and Voice System ArchitectureWe begin by walking through the architecture of a local VoiceAI system and why edge-based inference is becoming increasingly practical.Topics covered:- VoiceAI pipeline design- Local vs cloud inference tradeoffs- Overview of the tools used in the workshop- How the components interactParticipants will also review the architecture diagram that the rest of the workshop builds toward.Part 2 — Running a Local LLM (60 min)Participants will install and run a local language model using llama.cpp.Hands-on steps include:- Downloading and running a quantized LLM- Running the inference server from the command line- Exposing the model through an HTTP API- Testing prompts using curl and PostmanParticipants will learn how to treat the LLM as a service that other components can interact with.Part 3 — Speech-to-Text IntegrationNext, participants will add a local speech-to-text pipeline.Hands-on exercises include:- Capturing microphone input- Converting audio to text- Sending transcripts to the LLM server- Inspecting responsesThis step establishes the first half of the voice interaction loop.BreakPart 4 — Text-to-Speech IntegrationParticipants will add speech synthesis using Piper to generate spoken responses.Hands-on exercises include:- Installing and running Piper- Generating speech from model responses- Playing synthesized audio locally- Testing voice responsesAt this point, participants will have a complete speech → inference → speech loop running locally.Part 5 — Exposing the LLM via HTTPSIn this section, participants will add a lightweight reverse proxy in front of the LLM server.Topics covered:- Running a local HTTPS endpoint- Routin Speakers: Hussain Abbasi
Architecting a Secure, Scalable, and Cost-Effective Health system
2215A
Overview:In this architectural kata, participants will step into the shoes of a software architect tasked with designing a modern healthcare management system for a rapidly growing provider, MedSecure. The challenge is to create a system that integrates patient records, appointment scheduling, billing, and telemedicine while ensuring robust security, compliance with regulations, scalability, and cost-efficiency.Key Takeaways:Participants will learn how to navigate complex architectural decisions, balance competing priorities, and design systems that are not only technically sound but also aligned with business goals. This kata will sharpen their skills in the comfort of trade-off analysis, plus the high level of different architecture alternatives—key competencies for any future architect.---------------------------Prerequisites:-Basic Understanding of Software Architecture:Familiarity with common architectural patterns (e.g., monolithic, microservices, event-driven) and their pros and cons.-Basic Understanding of Cloud and On-Premises Solutions:Understanding of cloud computing concepts and services (e.g., AWS, Azure) and on-premises infrastructure.-Collaboration and Communication Skills:Willingness to work in a team setting, share ideas, and engage in constructive discussions.Optional:-Prior Experience in Healthcare IT: While not necessary, familiarity with healthcare systems and regulations would be beneficial.-Experience with DevOps Practices: Understanding CI/CD pipelines, containerization, and orchestration (e.g., Kubernetes) can help in discussions around scalability and deployment. Speakers: Javiera Laso
DevOps Foundations: From Code Commit to Production Confidence
2209
DevOps isn't a tool or a role — it's a culture shift that changes how teams build, ship, and operate software. In this hands-on workshop, we go beyond the theory and work through the full DevOps lifecycle using Git and GitHub.Over four hours, participants will get practical experience with source control, CI/CD pipelines, Infrastructure-as-Code, progressive delivery, and running systems in production with observability and SRE practices. By the end, they'll have a complete picture of how modern engineering teams actually operate — and the skills to start applying it immediately. Speakers: Vaibhav Gujral
Learn where to keep your variables to improve your app design, performance, and readability. We'll take an agnostic, high-level tour of what state management really is, including local vs global, dependency injection, and derived state. Then, we'll cover the Actions, Dispatch, and Reducers pattern and Mutators pattern in depth. You should walk away confident in your ability to use any front-end state management solution. Speakers: Abbey Perini
Java memory analysis is often slow, manual, and difficult to scale. Whether you’re investigating an OutOfMemoryError or proactively analyzing memory utilization, engineers still rely on tools and workflows that have changed little in the past 15 years.But what if AI could help explore and reason about heap dump data?In this talk, we’ll start with a quick tour of traditional open-source Java memory analysis tools and how they expose information from heap dumps. Then we’ll take things further by unlocking that data through the Model Context Protocol (MCP) and enabling an AI model to interact with it.You’ll see how to build an MCP server that exposes key insights from a Java heap dump, allowing an LLM to query object graphs, identify memory hotspots, and surface potential optimization opportunities. Through examples, we’ll explore how AI can assist with diagnosing memory issues, navigating complex object relationships, and suggesting areas for improvement in your application.By the end of this session, you’ll understand how to extend existing Java performance tooling with MCP and apply AI-assisted analysis to scale memory diagnostics across your organization. If you’re tired of manually digging through heap dumps through traditional UIs, this talk is for you. Speakers: Carl Chesser
Blending Product Thinking with Software Modernization
2208
In the world of software, products and systems don’t just remain static, they evolve, accumulate technical debt, and sometimes become an unmanageable mess of outdated frameworks, workarounds, and fragile dependencies.When dealing with a 15-year-old platform, the question isn’t just how to modernize but what to modernize. Should you refactor piece by piece or completely rebuild? What about adding that new feature for the Product Owner. The answer isn’t always obvious.This session explores how blending product thinking with software modernization leads to better outcomes. We’ll examine the lens of long-term product strategy, user needs, and business value. Using real-world lessons from a long-running SaaS product, a case study in modernizing a complex legacy platform, we’ll highlight how to balance technical constraints with customer expectations.Whether you’re leading a legacy transformation or trying to avoid one in the future, this talk will showcase some smart modernization decisions that don’t make the business take a full stop. Speakers: Brian McKeiver
Aspire isn't just for .NET, it's a polyglot orchestrator that can wire together Python, Node.js, Go, Java, and C# services under a single AppHost. Aspire brings automatic service discovery, connection-string injection, and a unified observability dashboard. In this session, we'll explore that idea hands-on through seven sample applications that range from Flask and Django to Go and Java.We'll start with how Aspire solves the polyglot problem: the service-discovery chaos, configuration fragmentation, and 15-step READMEs that plague multi-language repos. You'll see how it lets you bring any runtime into Aspire's lifecycle, and how environment-variable conventions replace hardcoded URLs and scattered .env files. We'll also look at OpenTelemetry integration so that distributed traces, structured logs, and metrics from every language land in one dashboard with no separate tooling per stack.As we walk through the demos, we'll cover the practical patterns that matter most to real teams: dependency ordering, health checks across languages, connection-string injection for Redis, PostgreSQL, CosmosDB, and Kafka, and what it looks like to debug a request that crosses from a React frontend into a Go or Spring Boot backend. Speakers: Chris Ayers
Home automation is transforming our lives, with smart switches, cameras, and wireless devices making our homes more comfortable and efficient. However, with so many different brands and proprietary ecosystems, managing these devices can feel like navigating a complex patchwork. That’s where Home Assistant comes in—a powerful framework to bring all your devices under one roof.In this 2-hour session, we'll guide you through installing Home Assistant, both locally and on container-based platforms. You'll learn how to configure it for various interfaces, including Z-Wave, Wi-Fi, and Zigbee. We’ll then explore how to automate everyday tasks, making your smart home even smarter. Finally, we’ll cover integration with voice assistants like Amazon Alexa and Google Assistant, giving you hands-free control over your devices.By the end of this presentation, you'll have the knowledge to become a home automation pro, ready to enhance your comfort and convenience. Speakers: Jackie Gleason
The 4C's of Cloud Native Security: A Layered Defence from Code to Cloud
2203
93% of organisations have at least one overprivileged Kubernetes service account. Most teams bolt on security tools, react to CVEs, and hope for the best because they never learned to think about cloud native security as layers. The Kubernetes documentation defines four of them: Cloud, Cluster, Container, and Code.In this talk, I'll walk through each layer using real production examples. How enabling AWS Security Hub and GuardDuty revealed blind spots we didn't know existed. Why RBAC misconfigurations and missing network policies are quietly exposing clusters everywhere. How Trivy caught vulnerabilities in base images we'd been shipping for months. And how Semgrep and Gitleaks in our CI/CD pipeline caught a hardcoded API key before it ever hit production.You'll leave with a practical framework for evaluating your own security posture layer by layer and a set of tools you can start using this week. Speakers: Osama Okunbo
Red-Green-AI: How BDD and Test Automation Became 10x Faster with AI Copilots
2204
Writing Gherkin scenarios is tedious. Writing step definitions is boilerplate hell. Maintaining Playwright selectors when the UI changes makes you want to quit testing altogether. But what if your AI copilot could generate comprehensive BDD scenarios from requirements, scaffold step definitions that follow your team's patterns, and even suggest test cases you forgot? Not "magic AI testing"—real behavior-driven development that's faster, more consistent, and actually maintainable.This session reveals how to supercharge your BDD workflow using AI assistance at every stage while maintaining test quality. You'll learn how to transform EARS-formatted requirements into Gherkin scenarios automatically, generate Reqnroll step definitions that follow your conventions, and leverage AI to identify edge cases and negative test paths you might have missed. We'll explore the complete pipeline from user story through executable tests: using steering files to enforce your BDD style guide, prompting patterns that generate maintainable Playwright locators, and techniques for keeping tests synchronized as requirements evolve. You'll see real examples from healthcare software where comprehensive test coverage isn't optional—it's a compliance requirement.But it's not all roses. We'll tackle the hard problems: when AI-generated tests give false confidence, how to review AI test code effectively, and maintaining the "test-first" discipline when AI makes it tempting to test-last. Walk away with prompt templates for scenario generation, patterns for AI-assisted test maintenance, and a decision framework for when AI helps versus when it hurts your testing culture. Whether you're using Reqnroll, Cucumber, or SpecFlow with Playwright or Selenium, you'll learn how to leverage AI to write better tests faster—without sacrificing the thoughtfulness that makes BDD valuable. Speakers: Patrick Liekhus
The UX of AI: User Interaction Beyond the Chat Box
2206
As a developer, AI can feel fun, exciting, and full of potential – but do our users always feel the same way about the AI features we add to their software? From a UX perspective, AI comes with a whole new set of considerations around user trust, privacy, and security. From a UI perspective, AI brings new interaction patterns, new icons, new visual cues, and so much more! If we want people to get the most from the AI features we build, we have to teach our users how to use them. Let's look at ways to introduce these new capabilities in our apps and guide our users through these new patterns and processes – ideally without making them throw their phone out a window. Speakers: Kathryn Grayson Nanz
Don’t Panic: A Hitchhiker’s Guide to Agentic DevOps
2104A
We’ve all seen the demos where an AI writes a "To-Do" app in thirty seconds. It’s impressive, sure, in the same way a dog riding a bicycle is impressive, but it’s not exactly how we build production-grade software. In the real world, the SDLC is messy, our pipelines are held together by legacy YAML, and "moving fast" usually means "breaking things we didn't know existed."Shifting from simple AI assistants to autonomous agents that can provision infrastructure and remediate incidents, requires us to stop asking "what can it build?" and start asking "how do we manage it without losing our minds?"This talk will look past the hype to the practical integration of AI-augmented DevOps. We’ll explore the transition from manual automation to agentic pipelines, the critical importance of "Human-in-the-loop" guardrails, and why the most important part of AI-driven DevOps and DevEx isn't the code it generates, but the cognitive load it *actually* removes. At the end, we'll have a roadmap on how to actually use this stuff without making everyone very angry. Speakers: Jeremy Meiss, PJ Hagerty
You shipped the agent. It works in the demo. Your team is proud of it.Look closer: shared context everywhere, agents that cannot function without an orchestrator holding their hand, chains that fall apart at the first unexpected input. You have built a distributed monolith. The industry did this with microservices, and we are doing it again, except the failure modes are worse. When a microservice fails, you get a 500. When an agent fails, you might get a 200 and a corrupted state.This talk introduces AWAF, the Agent Well-Architected Framework: an open specification for building production-ready AI agents, inspired by the AWS Well-Architected Framework and adapted for the specific ways agent systems break. AWAF defines 10 pillars across three tiers. The Foundation ensures your vertical slice works end to end before anything else matters. Six adapted cloud pillars cover operational excellence, reliability, security, cost, and performance, where the tradeoffs look very different in agent land. Three agent-native pillars carry extra weight because agents reason, plan, and act rather than simply serve requests: Reasoning Integrity, Controllability, and Context Integrity.The framework is paired with awaf-cli, a CI-native tool that scores your architecture on every pull request and fails the build when something regresses.You will leave with a concrete framework for evaluating whether an agent is actually production-ready, the architectural pitfalls teams repeatedly hit, and a CLI to install the same day.Your CTO is not going to ask, "Does it work?" They are going to ask, "Can we trust it in production?" Speakers: Yogi Aradhye
Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing...an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base. Speakers: Nathaniel Schutta
When a database is slow, you have two options: burn more money with your cloud provider, or roll up your sleeves and fix it. Many teams click the scale up button first - more RAM and CPU takes 60 seconds and buys them time. But it inevitably comes back worse than before.My team recently faced the same situation. Scaling up resources had deferred the problem for awhile, but it was time to figure out what was going on. Our system was overwhelming the database in multiple ways: missing indexes, N+1 queries, ORM malfeasance, even a dodgy connection pool.This talk will walk you through the process we used to fix them: how to decipher telemetry, review query plans, and tune indexes or data access patterns. The issues we uncovered are common in many database applications and you’ll come away with a practical blueprint for resolving them. Speakers: Matt Burke
Would You Let an Intern Change Production? Where AI Fits in CI/CD
2205
AI is reshaping software delivery, and it’s not going away. The question for platform engineers isn’t whether to use AI in the CI/CD pipeline—but where and how. This session shares lessons learned from integrating AI into a continuous delivery tool, including what worked, what didn’t, and where guardrails are essential.Because AI is inherently non-deterministic, it should not decide the actual steps executed in a pipeline—doing so introduces risk and compliance concerns. Instead, AI can add value by generating deterministic pipeline definitions, triggering workflows, analyzing failures, and recommending remediation steps.Platform engineers, DevOps engineers, or the people in charge must define the boundaries. The key takeaway: people are non-deterministic too. Treat AI like you would a human contributor—constrain what it can do based on trust. For some organizations, that may mean “intern-level” access limited to dev and test. For others, it may act like a senior engineer—able to propose process changes, but never deploy directly to production. Speakers: Bob Walker
Technology is getting closer to magic every day. This entertaining session includes some audience magic, technology, and the forefront of what's possible in AI, all wrapped into a performance with front-end architecture.In this session, we review tools in a symphony of composition that make an ideal user experience, and the fun of magic.I'll be covering useful SASS API, React Native, and Front End Coordination in a mission-critical production. We'll have equal parts code and story that resonate and delight engineers. Speakers: Gant Laborde
The Art of Falling Face Up: Building Resilience and Embracing Change
2210
Change is a constant in our lives, and it can be both exhilarating and unsettling. Whether we are facing changes in our personal or professional lives, how we react to them can determine our success and happiness. In this talk, we'll explore the concept of resilience and how it can help us embrace change and thrive in the face of adversity.We'll examine the traits and skills that enable us to develop resilience, including emotional intelligence, flexibility, and problem-solving. We'll also discuss the importance of embracing change and the opportunities it can present, even in the most difficult of circumstances.Throughout the talk, we'll share stories of individuals who have overcome adversity and embraced change, highlighting the common themes and strategies that have enabled them to persevere and succeed. By the end of this talk, you'll come away with a deeper understanding of how to build resilience and embrace change in your own life. You'll learn practical strategies for building emotional intelligence and problem-solving skills, and how to leverage change as an opportunity for growth and personal development. Whether you're facing a significant life transition or simply looking to build your resilience, this talk will inspire and equip you to "fall face up" and thrive in the face of change. Speakers: Isaac Levin
Free as in Liability: Open-Source Sustainability and the Java Advantage
2209
Every production Java application depends on a myriad of binaries somebody else built, patched, tested, and certified. But who funds that pipeline?And what happens when parts of it go dark?This session maps the real economics of open-source sustainability through the Java ecosystem: the infrastructure costs behind certified binaries, the various compliance deadlines, and the mounting pressure on maintainers from AI-generated noise.Java's layered ecosystem: coordinated quarterly security, vendor-neutral distributions, foundation governance, and strong commercial stewardship - is better equipped for this moment than any other platform. But even here, your open-source stack is accumulating risk in ways you might not expect.We'll challenge some comfortable assumptions about how open-source software is really maintained and secured, including a blind spot most organisations miss entirely: end-of-life dependencies your scanners report as clean, because nobody upstream ever checked.You'll walk away with a method for finding EOL components your scanners miss, and a clear view of when third-party EOL support makes more sense than a rushed migration. Speakers: Steve Poole
Ditch your backlog and start building stuff that actually matters
2206
Your backlog is lying to youIt promises order but delivers anxiety. It says "we'll get to this eventually" but really means "never." We were drowning in our endless list of "someday" tasks for years until we killed our backlog, and our team finally started shipping what actually mattered.In this talk, I'll show you what we learned from ditching the traditional backlog in favor of focused work cycles and strategic prioritization. Who could have known that when you stop pretending you'll someday build everything on that list, you can start actually focusing on building the right things, right now.We swapped time estimates for time budgets. We traded the illusion of planning for actual progress. And we went from accumulating technical debt to actually paying it down.There were trade-offs and challenges along the way, and I'll candidly share those as well. Whether you're at a scrappy startup or navigating the enterprise, you'll walk away with a new lens on how to move faster without the backlog baggage.Ready to dump that backlog? Speakers: Glenn F. Henriksen
MCP with .NET: securely exposing your data to LLMs
2215A
Model Context Protocol is rapidly becoming the de facto standard for LLMs and systems to communicate.This session explores the fundamentals of the MCP protocol, how to safely implement it into our applications with the .NET SDK and Microsoft Agent Framework / Semantic Kernel, plus key considerations for building a production-ready system – like security, auth, rate limits, and observability.We'll cover the basics of setting up an MCP server in .NET and exposing executable functionality as Tools, enabling any client to communicate with our application. We'll understand how Semantic Kernel's familiar concepts of Plugins and Functions map over to the world of MCP.Let's walk through integrating .NET's native Identity services to align with MCP’s authentication spec, enforce role-based permissions using Filters, and apply rate limiting middleware to keep the server reliable and secure.Finally we will discuss approaches to running intelligent .NET applications in the wild on Azure; with .NET Aspire providing scaling and OpenTelemetry, deployed on Azure Container Apps, and using an AI Gateway with appropriate policies via Azure API Management to create a hardened system. Speakers: Callum Whyte
WebAssembly is a new cross-browser emerging standard providing a "target bytecode" for languages that want to compile into something that can be run natively inside the browser; in many ways, it's the culmination of the effort to provide developers with an ability to do "browser plug-ins" without having to be browser-specific, alongside the safety and portability of the Java applet or Flash game. In this talk, we'll go over some of the different tools of the WebAssembly world, talk briefly about what WebAssembly does--and doesn't--provide, and look at how to get started using WebAssembly while we wait to see how the world reacts and/or moves to adopt this in a more widespread fashion. Speakers: Ted Neward
10 Vectors of Cloud Exposure (And the Framework to Mitigate Them)
2204
Your cloud probably won’t get hacked because of some elite nation-state exploit. It’ll happen because someone pushed a hardcoded secret, left an S3 bucket open, or gave a CI/CD role just one permission too many.This talk is a guided tour through 99 real-world ways to get breached in the cloud, based on patterns seen in actual incidents including one that almost cost us $1M. We’ll dissect misconfigurations across IAM, storage, Kubernetes, supply chain, CI/CD, and more and show how these slip past even the most mature teams.But it’s not just a list of problems. We’ll map each one to a first-principles fix, helping you build a mental model for secure infra design, not just duct-tape remediations. We'll see:• Why breaches aren’t usually about “bad code,” but about insecure defaults and over-trusting architecture• How to spot the security debt you’re accumulating silently• First-principles patterns for identity boundaries, auditability, least privilege, and recoveryThis isn’t your standard security talk. There are no vendor pitches, no magic scanners just patterns, principles, and hard-won lessons from the trenches of modern DevSecOps. Speakers: Prerit Munjal
Indispensable Principles for Designing Complex User Interfaces
2210
Complex, data-intensive web applications pose significant, difficult challenges. Mission-critical apps often require compact, narrow, crowded interfaces that only a master Excel ninja could love (or use). Welcome to endless data, filters, sorting, tabs, drop-downs, modals, buttons, and voluminous grids. How do we balance vital functionality with real-world usability?You CAN make stellar, efficient, easy-to-use mobile and web apps even when faced with these stark challenges. In this session, you’ll learn the tips, tricks, and secrets to help you masterfully define and design compact digital products for expert users (they need our love, too).These principles will change the way you think about constrained interface design. And your users will love you for it. Speakers: Dean Schuster
The Humans Architect the System, the AI Writes the Code
2102A
At System Initiative, we don't write code. Not because we can't — because we decided not to.Every line of code in our new project, swamp, is generated by an LLM operating within strict design guidelines we've crafted and maintained. We don't accept pull requests but we happily accept contributions. If you want to contribute, you open an issue, we discuss the problem, refine the design together and let the AI build it. This keeps the supply chain intact and trustworthy. That's not a gimmick, it's the thesis made real. This talk is about what it actually looks like to run an engineering team this way — the discipline it requires, the design guidelines that make it work, and what we learned building swamp: an AI-native automation CLI for operations teams.What we've learned is that the quality of what the AI produces is a direct reflection of how well you can express what you want. Vague guidelines produce vague code but sharp constraints produce good code. That's true for swamp, and it's true for how we build swamp.We'll cover:- Why we made the decision to stop writing code and what changed when we did- How design guidelines replace pull requests as the primary contribution mechanism- What "architecture-first" means in practice when an LLM is your entire engineering team- How swamp applies those same principles to operations — and why that matters as AI starts driving infrastructure decisions- How AI gives you back the work you got into this industry to do — systems design, not syntaxThe future of software isn't humans writing less code, it's humans getting better at expressing what they want. We're living that experiment in the open, come see what we've learned! Speakers: Paul Stack
It is the age of AI, and there is a huge opportunity for developers to infuse apps with solutions powered by generative AI and large/small language models. Modern AI is big opportunity to streamline and automate developer workflows for better productivity. There are some challenges though – AI Models often lack context, and AI Agents need expertise to reliably pull off complex workflows across disparate systems.Model Context Protocol (MCP) can help. Developed as an open standard, MCP aims to provide a standardized way to connect AI models to different data sources, tools and non-public information. The point is to provide deep contextual information/APIs/data as tools to AI models/agents—MCP services also support robust authentication/authorization toward executing specific tasks on behalf of users.Developers can think of MCP as a common standardized language for information exchange between AI Agents/systems - MCP is growing in popularity and is showing a lot of promise as the emerging standard that bridges AI models with the tools they rely on. Beyond the hype, let’s understand the promise of MCP and explore tooling to easily create MCP Servers/Clients. With official SDKs, it is a breeze to work with MCP and boost AI Model responses or surface tools to extend AI Agents. Developers could bring their own data, APIs, services and more through MCP - and have it surfaced to any AI Agents. Heard of Skills/SubAgents – MCP works with those as well. MCP provides a standardized protocol for bringing contextual expertise to the AI world and light up unique workflows for integrations – upwards and onwards. Speakers: Sam Basu
Let's face it - your AI app is probably broken. Maybe it calls the wrong tools, retrieves the wrong data from a RAG system, or even hallucinates more than a 1970's music festival audience.The fun of developing AI apps is their non-deterministic nature. You can't write unit tests the way you are used to, so TDD is out. Even QA may pass your app only for it to fail in prod with different inputs, or model updates.In this session, I propose a new methodology to shift left with AI app development, "evaluation driven development". Evaluations allow you to use AI and other tools to score your AI apps capabilities and responses, using more powerful or specialized models to evaluate the ones you use day to day.If you build in evaluations during development, you can have more confidence in what you are shipping to QA, staging, or production. Evaluation driven development even allows you to bring in AI governance earlier in your development cycles, using evaluations from your compliance teams as part of your development processes.By the end of this session you will understand how this new methodology can ensure quality and compliance in the apps you build. Speakers: Jim Bennett
How I Gave Up Clean Architecture, and Why My Code Got Simpler
2102B
I did everything right. Clean Architecture, layered services, repositories, interfaces for everything. The intention was good. The result was a lot of indirection and a simple feature scattered across a dozen files.Eventually I tried new techniques, and the code got simpler. Each feature owns everything it needs: command, handler, persistence, and tests. All living together instead of being spread across layers. Easier to understand, easier to change, easier for new developers to navigate. Turns out I was maintaining more structure than my system actually needed.This talk walks through the transition from layered architecture to vertical slices in an open-source .NET system. We'll cover why traditional layering tends to accumulate accidental complexity, how Vertical Slices, along with A-Frame Architecture and Railway Oriented Programming, simplify feature development!Sometimes giving up a pattern is the best architectural decision you can make. Speakers: Erik Shafer
Modern runtimes like Java, Go, and Node.js face a critical "resource gap". They require a massive CPU burst for JIT compilation or dependency loading, only to settle into a much leaner steady state seconds later. Historically, we had to over-provision Pods for this peak, wasting thousands of cores across clusters.With In-Place Pod Resize in Kubernetes v1.35, we can finally implement a startup boost strategy. This session moves beyond the theory to show the technical "how-to" where we will demonstrate how to build a reactive workflow that provisions high initial resources and then "shrinks" the footprint silently via the resize sub-resource.Beyond the "how-to", we must address the "shrinkage trap" and explain how to time the resource reclamation to avoid aggressive CPU throttling immediately after boot. We will compare different implementation patterns including sidecar-driven patches, a dedicated boost-operator, and the native Vertical Pod Autoscaler, ensuring your applications don't just start fast but stay stable.Stop paying for peak startup power during hours of steady-state operation. Speakers: Graziano Casto
Fix It Fast: The SQL Developer's Execution Plan Playbook
2205
If you're a SQL developer or DBA who has ever opened an execution plan, squinted at it for a minute, and gone back to guessing, you're in good company. It tells you exactly what it did, why it did it, and where it went wrong. Some plans leave you clues. Others greet you with a warning sign the size of a billboard. Either way, you need to know how to read it. After pulling up an execution plan on a query that had been "running slow for a while," the original solution on the table was to scale up the server for more resources. What I found instead was a Hash Match spilling gigabytes to tempdb on every single execution. I stopped treating execution plans as optional reading after that. We'll start with the foundation most people skip: index seeks, scans, and key lookups, what each one actually means to your query's performance, why the optimizer reaches for each one, and the scenarios where best practice is just a polite way of saying we never tested this at scale. And let's be honest, testing at scale is one of the hardest things we do. That's exactly why knowing how to read the plan matters. From there we get into where most performance mysteries actually live. Why did the optimizer pick a Hash Match here and a Nested Loop there? Why is your perfectly written query doing a table scan on a fully indexed table? We'll walk through the relationship between your index structure and join algorithm selection, how to catch a plan that's quietly bleeding performance, and what to do when the optimizer made a decision that made sense on paper and fell apart in production. You'll leave with a repeatable framework for reading any execution plan you've never seen before, not just the ones we cover in this session. Bring a query that's been bothering you. We might just figure out what it's been trying to tell you. Speakers: Konstantin Melamud
GitOps in Practice: What Nobody Tells You About Multi-Environment Deployments
2202
The theory of multi-environment CI/CD pipelines is clean and satisfying: code flows from dev to staging to production, environments are identical, deployments are predictable. The reality is messier and the biggest culprit is something almost nobody talks about: environment drift. Staging never actually matches production. It starts small like a config value here, a slightly different connection string there. Then one day your staging pipeline goes green and production goes on fire. If you've been there, this talk is for you. Drawing on hands-on experience building and managing CI/CD pipelines across Azure DevOps, GitHub Actions, GitLab CI, Octopus Deploy, and Jenkins for large organizations, I'll share what the documentation doesn't cover: the operational realities of keeping multiple environments honest over time.What I hope you walk away with:Why environment drift happens and the organizational and technical patterns that accelerate it.Infrastructure-as-Code strategies that actually enforce environment parity (and what to do when IaC isn't fully adopted).How to use pipeline gates, automated environment validation, and deployment manifests to catch drift before it hits prod.Config and secret management approaches that don't become a maintenance nightmare at scale.Hard-learned lessons from real enterprise pipelines — including what I'd do differently.This is a practitioner's session. We'll skip the happy-path demos and focus on what happens after your pipeline has been running in the wild for 18 months. Speakers: Ben Hooper
Web components enable creating web-based UI components that are directly supported by web browsers. They can implemented and used without downloading libraries or tools, and without configuring a build process. Web components can be used in conjunction with most web frameworks or without any framework.All that sounds great, but why should YOU learn about web components? You likely already have a favorite web framework that is getting the job done. But future project teams may not opt for using that framework. And after working hard to implement great components, wouldn't it be nice if they could be used in multiple applications, regardless of the chosen framework?Web components are not new technology. Web browsers began supporting their use without polyfills in 2016. But web components have been ignored by many web developers. If that includes you then this talk will answer questions like the following:- What are the pros and cons of building and using web components?- Where can I find existing web components that I can reuse so I don't have to write everything from scratch?- How are web components included in a page? - What are the options for building new web components?- What is the purpose of each lifecycle method?- What are the benefits does using a "Shadow DOM" and how is it used?- How can template elements be used to make DOM building more efficient?- How can I customize the styling web components from outside their code?- How can web components trigger events that notify code outside them about changes in their state and user actions?- What do I need to know to get web components to play nicely with HTML forms?- How can web components share state between them and react to state changes?- How can I use browser DevTools to test web components?- Can AI tools generate the code for web components? Speakers: Mark Volkmann
Nobody Wants to Go to Your Meeting. (Let’s Fix That.)
2215C
Your calendar is full of meetings where attendees mentally check out. That's not a people problem. It's a design problem. As the meeting organizer, you're the designer.Most meetings fail for the same reason most products fail: the meeting organizer never stopped to ask what their attendees actually need, what outcome would make the time worthwhile, or whether a live session is even the right format for the job. The result is a standing meeting that becomes an obligation, a brainstorm where the loudest voice wins, a decision meeting that ends with "let's take this offline", and a calendar invitation that should have been an email.This session makes the case that every meeting is a product. It has users with real needs. It has a value proposition that either holds up or doesn't. It has a format that either creates the conditions for something meaningful to happen or gets in the way. Treat it like a product, and people show up prepared and engaged. Ignore that, and you get laptops open, cameras off, and the same conversation next week. That's because most meetings were never designed to answer: what can only happen in real time, among these specific people?You'll leave with:- A framework for designing meetings that people actually want to attend and can explain why afterward- A method to audit your recurring meetings and diagnose exactly which ones are failing and why- Specific redesign moves for the three meeting types most likely to waste everyone's time: the status update, the decision meeting, and the brainstorm Speakers: Anitra Pavka
Trash Talk - Exploring the memory management in the JVM
2208
In the realm of Java programming, understanding memory management and garbage collection mechanisms cannot only be helpful for optimizing performance and resource utilization but also in general will help you to use the right garbage collector for your application. This session will be about memory allocation, object lifecycle, and garbage collection strategies within the Java Virtual Machine (JVM). Attendees will gain insights into memory allocation strategies, object retention policies, and various garbage collection algorithms like generational and concurrent collection. So when you are interested in getting more knowledge about which garbage collector to use best for your application or about memory management in the JVM, this session is for you. Speakers: Gerrit Grunwald
Did you know that the .NET compiler turns our async methods into a struct? And that .NET adds a try/catch block to each of these classes, potentially hiding thrown exceptions? It's true!In this session, we will learn how to best use async/await in C# by analyzing how .NET compiles our async code.Join me as we take an existing app and optimize its async code together, showing off performance gains, better exception handling, improved run-time speed, and smaller app size! Speakers: Brandon Minnick
Who Gets Your Laptop When You Die? Making a Contingency Plan for Your Digital Life
2205
Who gets your laptop when you die? And even if they know how to unlock it, what will they find? If you become incapacitated, will someone be able to access your medical and insurance information? How can the important people in your life get the digital assets they need without compromising your personal security?Our lives are now overwhelmingly digital, yet many of us have no plan for what happens to our accounts, devices, and data in an emergency. The same security measures that protect our life’s work become an impenetrable barrier for those who may need to manage our affairs. Without preparation, the people we trust most may be left scrambling to access critical information while navigating an already stressful situation. In this talk, I’ll share what I’ve learned after experiencing this situation firsthand. We’ll cover practical, easy-to-implement strategies for creating a personal digital emergency plan. You’ll leave with concrete steps to smartly manage two-factor authentication, add legacy contacts, securely share password vaults, and organize critical information so trusted people can step in when necessary. Emergencies are stressful, but preparing for them doesn’t have to be. With a little planning, you can create a system that protects both your privacy and the people who depend on you. Speakers: Ruby Rios
WTH is Chaos Engineering?! A Quick Look at Breaking Things on Purpose
2206
Why would anyone intentionally break their own systems? Welcome to chaos engineering.In this talk, we’ll clarify the what and why behind chaos engineering and you’ll learn how small experiments in failure can help you uncover blind spots, harden your systems, and sleep better at night.We’ll look at real-world use cases, tools that make it easy to get started locally, and how to run chaos experiments without blowing up production. Speakers: Kiah Imani
How My Team Got Worse With AI: The Hidden Tax of Generated Code
2102A
We armed our engineering teams with AI assistants, expecting a massive leap in productivity. Instead, we started noticing a troubling shift. Pull request discussions lost their personal touch, devolving into debates over generated snippets. System knowledge became shallower. We realized that by eliminating the friction of writing code, we were accidentally automating the thinking required to understand it.In this session, we will explore the reality of being a Tech Lead in the AI era. The industry is currently pushing to turn creative software engineering into an assembly line of prompt execution. But code is a persistent document; it is what lives in the repository and what the next developer has to load into their brain. The prompt, on the other hand, is ephemeral. If we bypass the struggle of learning the system, we lose our ability to maintain it.Drawing from my experience leading teams in different organizations, we will look at what happens when developers basically outsource their learning cycle to LLMs, and how leadership must adapt to protect the integrity of the architecture.What we’ll cover:* Local vs. Global Coherence: Why AI provides the illusion of perfect syntax on a line-by-line basis while often failing completely at the architectural level.* The 80/20 Inversion: How our day-to-day work shifted from spending most of our time authoring solutions to spending that time reading and auditing AI output.* The Code Review Shift: Moving your team from checking for basic syntax errors to conducting deep architectural audits, recognizing that an LLM will never debate system design with you.* The Confidence Spiral: How over-relying on code generation degrades a developer's learning cycle. The more the machine writes, the less developers trust their own judgment.What you will take back to your team: Instead of generic agile advice, you will leave with concrete management tactics to restore the human touch in technical discussions. We will cover specific rules of engagement for AI tools—such as shifting your PR process from traditional bug-checking to mandatory Architectural Audits —and actionable ways to ensure your engineers continue to build the deep mental models required to own a complex system. Speakers: Fernando Cargnelutti
AI Sandboxes: Running Coding Agents Safely in Production-Grade Environments
2104A
The number of cyber attacks and security risks related to Coding Agents has sky rocketed. AI coding agents like Claude Code, Codex CLI, and Gemini CLI don’t behave like your typical developer tools. They install system packages, modify configurations, delete files, run services, and even spin up Docker containers, often requiring constant permission prompts or risky access to your host machine.This talk explores Docker Sandboxes as a new execution model for autonomous coding agents. Built on microVM-based isolation, Docker Sandboxes provide disposable, agent-safe environments where coding agents can run unattended while remaining fully isolated from the host system.We’ll walk through why traditional approaches like OS sandboxing, containers, and full virtual machines, break down for agent workflows, and how Docker Sandboxes combine the developer experience of containers with the hard security boundaries of VMs. Using live examples, we’ll show how agents can safely run Docker-in-Docker, install dependencies, access only the project workspace, and be reset instantly. By the end of this session, you’ll have a clear mental model for when and how to use Docker Sandboxes to unlock higher levels of agent autonomy without compromising safety, security, or developer experience. Speakers: Shivay Lamba
Headroom: A Context Optimization Layer for LLM Applications
2102B
LLM tokens are expensive. With context windows expanding to 200K+ tokens, a single API call can cost several dollars & in production systems handling thousands of requests, these costs compound quickly.Most optimization efforts focus on model selection or prompt engineering, but the context itself often contains massive redundancy.Headroom is an open-source Python library (https://github.com/chopratejas/headroom) that sits between your application and your LLM provider, transparently optimizing context before it reaches the model.The core insight is simple: LLM contexts—especially in agentic workflows—are filled with repetitive tool outputs, verbose JSON arrays, and boilerplate that consumes tokens without adding proportional valueHeadroom introduces novel concepts such as reversible compression, cache aligners, compression routers, and even persistent memoryReal-world results:- 50-90% token reduction on typical agentic workloads- Drop-in integrations for LangChain, OpenAI, Anthropic, and any OpenAI-compatible provider- Zero code changes required when using the proxy server Speakers: Tejas Chopra
Avoidifying Over-Complexification: Rooting Out Over-Engineering in Your Projects
2104B
Discover the art of unraveling complexity in your software projects and returning to the fundamental principle of KISS ("Keep It Simple, Software developer"). As complexity grows in any system, so do its potential points of failure, underscoring the importance of mastering the art of software architecture simplification.Journey with us as we delve into the most common mistakes that pave the path to software over-engineering. We'll talk about the allure of gold plating, superfluous features, and premature optimization, among other popular complications.Your takeaway will be some practical strategies that will help you hold the line on over-engineering. In short, you will learn to strike the right balance between power and simplicity in your software projects. Speakers: Jonathan "J." Tower
Serverless Beyond the Happy Path: What Actually Happens in Production
2204
Most serverless talks end at the demo. This one starts where production begins.Serverless platforms promise simplicity and scale, yet many teams discover the real complexity only after launch. Retry storms, poison messages, cold‑start amplification, runaway costs, and brittle deployments often manifest weeks or months later, when traffic increases, or the original team has moved on. These failures aren’t edge cases; they’re the result of designing for the happy path.This session focuses on what actually happens when serverless systems run in production. Rather than walking through services or frameworks, it examines execution behavior: how functions retry, overlap, re‑enter, and fail under real load. Attendees will explore why common mental models break down, how idempotency must be treated as a system‑level concern, and why naïve concurrency assumptions lead to cascading failures.The session then connects execution semantics to operating reality, showing how observability and cost signals reveal system behavior—not just errors—and how to detect retry storms, poison messages, and cold‑start side effects before they become incidents.The final portion is a live walkthrough that hardens a “reasonable but wrong” serverless Function app using concrete patterns for failure containment, versioning, deployment safety, and ownership. Speakers: Chad Green
NoSQL Data Modeling: Why Your Schema-less Database Still Needs a Plan
2202
The "schema-less" promise of NoSQL is often a trap. In reality, the lack of a schema makes your data design even more critical. A poor data model in a distributed system doesn't just slow down queries—it breaks scalability and inflates your cloud bill.In this session, we will walk through the lifecycle of a NoSQL model, from JSON specifications to advanced partitioning strategies. You will learn how to handle the nuance of NULL vs. undefined values and, crucially, how to select a Partition Key that prevents "hot partitions." We’ll conclude by exploring how Materialized Views can solve the puzzle of cross-partition queries without sacrificing speed.Join us to see why "just dump it in JSON" will not work in a distributed database. Speakers: Hasan Savran
Our journey from Gitflow to Trunk Based Development
2203
Having worked with Gitflow for years, we have recently transitioned to a Trunk Based Development approach to accommodate the expanding needs of our product.During this session, we'll quickly go over the differences between both branching strategies before diving into why we switched. We'll then explore the steps we undertook to make the transition possible: We'll discuss how we restructured our software development lifecycle, the initiatives we set up to foster the adoption, how did we use Feature Flags to achieve Continuous Deployment, how Feature Environments and Non-Regression Tests upped our confidence in shipping to production every day, and finally we will share the mistakes we made along the way.By the end of the presentation, you'll have a comprehensive understanding of Trunk Based Development helping you to decide whether it's appropriate for your engineering teams. Speakers: Ludovic Toison
When heavy computation runs on the main thread, even fun, polished apps start to feel janky. In this session, I'll use small JavaScript demos to show how to spot UI-blocking work, move expensive tasks into Web Workers, and keep interactions smooth with debouncing, progress updates, and cancellation patterns. You'll leave with practical patterns you can use right away, plus a clearer mental model for when Web Workers are worth it. Speakers: Courtney Yatteau
The Self-Mastery Journey: A Structured Approach to Professional Development
2209
Professional growth rarely happens in a single leap. It is built through countless small steps, intentional reflection, and continuous learning. Yet, many professionals lack a structured framework to guide this journey, leading to stagnation or burnout.This session breaks down self-mastery into three practical pillars: Continuing Education, Community Involvement, and Self-Reflection. We will use established models to help you understand your own operating manual:- The VARK Model: Discover your specific learning preference (Visual, Auditory, Read/Write, Kinesthetic) to absorb new technologies faster.- Communication Styles: Analyze whether you are a "Think-to-Talk" or "Talk-to-Think" processor to improve how you collaborate in meetings.- The EASE Framework: Use a structured reflection cycle (Experiential, Action-Oriented, Structured, Emotional) to turn daily experiences into career wisdom.Leave with a clear roadmap for investing in yourself that goes beyond standard career advice.Key Takeaways:- Optimize Your Learning: Identify your VARK style to tailor how you consume information and upskill effectively.- Refine Your Communication: Understand your processing style to engage more effectively with your team and stakeholders.- Turn Experience into Insight: Apply the EASE framework to conduct meaningful self-retrospectives that drive continuous improvement. Speakers: Fred Deichler
My code is faster than yours... let me prove it to you!
2209
You stare at the notification on your screen, your heart sinking with each passing second. It is a pull request from your colleague, Lisa, asking you to review her code. You take a deep breath and click on the link, hoping for a smooth review process. Little did you know, this simple task would soon turn into a daunting challenge.As you scan through the code, one particular line catches your attention - a regular expression. Immediately, you knew this was a problem waiting to happen. You leave a comment on the pull request, expressing your concerns about the regex. You point out that it is not only slow but also difficult to read and maintain. You suggest Lisa replace it with a more explicit block of code that achieves the same result, albeit at the cost of increased length.Within minutes, Lisa responded to your comment, refusing to make any changes. She argues her regex is not only shorter but also just as easy to understand. She challenges you, stating she wouldn't change it unless you could prove your proposed solution was faster.Your panic levels begin to rise. You have never done any performance comparisons before. You desperately search through your bookmarks, hoping to find something that could help you in this predicament. Then it strikes you - you remember that François Martin will give a conference talk showing how to do microbenchmarking in Java using JMH, scheduled to take place in just a few days. It was like a lifeline was thrown to you. With renewed hope, you quickly register for the conference, eager to gain the knowledge you need to save this code review. You sigh with relief, marking the talk's date in your calendar with a red pen and counting down the days until the conference... Speakers: François Martin
Your Assumptions Are Wrong, and Your Software Is Bad
2205
Gathering requirements is hard. We need the right mix of clarity and flexibility to ensure that everyone understands what needs to be done without committing to specific implementation details up front. But how do we accomplish this when everyone's needs and perspectives are so different? What's more, how can we effectively communicate and collaborate in an increasingly remote world? In this session, we will talk about the different stages of requirements gathering and the kinds of questions we should be asking ourselves and each other. From the customer to the developer, and everyone in between, this talk will have a little something for all who participate in the product development cycle. Speakers: Bill Parrott
Aspire to More: Smarter Onboarding and Cleaner .NET Development
2211
What if getting up and running with distributed .NET apps didn’t feel like assembling IKEA furniture blindfolded? Say hello to .NET Aspire, a toolkit that trims the complexity and lets you focus on what matters: building great software, faster.In this talk, I’ll show you how Aspire helps new developers to your project hit the ground running and seasoned teams stay aligned. We’ll walk through how to add Aspire to an existing application, from set up to integration, and highlight some real wins along the way. With built-in support for service discovery, observability, and local orchestration, Aspire takes care of the plumbing so you can focus on solving real problems. We’ll cover how you can use it to cut onboarding time and reduce “dev friction”, all while keeping code clean and architecture consistent.Expect practical tips, a few “aha!” moments, and a fresh look at what modern .NET development can be. Whether you're leading a dev team or mentoring new talent, Aspire might just become your secret weapon. Speakers: Joseph Guadagno
Programming your way up a Skyscraper - Python in the Built World
2208
When I started working on the latest high rise for San Francisco a challenge stood before me: How am I going to do this without losing my mind? Thankfully Python coding came to the rescue. This talk will showcase all the tools built around Python that can make architecture dreams come true!The audience will learn about how open source coding has been used for buildings. There is a burgeoning industry for software development and open source tools to be used in building design and construction. I want to show everyone how much interest there is in open source tools in this sector and my intent is to gain audience interest and grow the open source community in Architecture.This talk explains how I used Python to dive into open source tools for my projects. This includes scripting with open source tools like Dynamo, Rhino and Blender. My talk is meant to encourage others to learn how to use open source tools with Python and enhance their projects whether it is in digital or physical space. Speakers: Tadeh Hakopian
Most web application security advice boils down to "don't do the bad thing." But knowing the OWASP Top 10 doesn't tell you where to start when you're staring at an existing codebase with no security headers, unvalidated inputs, and CORS set to `*`.This talk is the prioritised checklist I wish I'd had. Through live demos, I'll walk through ten concrete steps - from dependency management and input sanitisation to CSRF protection and rate limiting - showing what each vulnerability actually looks like when exploited, and what the fix looks like in real code. No slides full of bullet points. Each step gets a demo: here's the attack, here's the defence, here's what to do on Monday.Whether you're securing an existing application or building a new one, you'll leave with a clear, ordered plan for hardening your web app - starting with the changes that have the biggest impact for the least effort. Speakers: Ben Dechrai
Adopting Agentic Development: A Practical Blueprint for AI-Driven Engineering Teams
2102B
AI agents are rapidly entering the software development lifecycle. Teams are experimenting with coding agents, workflow agents, and domain specific agents that generate code, run tests, analyze systems, or assist with operational tasks. However, most engineering organizations quickly discover that adopting agentic development is not simply a tooling problem. It requires new team practices, new project structures, and new guardrails to ensure these systems produce reliable outcomes.There is currently no universal blueprint for how teams should adopt agentic workflows. The ecosystem is evolving quickly, with emerging standards such as Model Context Protocol (MCP), Agent to Agent protocols (A2A), rapidly changing agent frameworks, and new tools appearing almost weekly. Teams must determine how to move past the experimental stage safely, how to structure projects so agents can operate effectively, and when an agent should perform work versus when a human engineer should remain in the loop.This talk focuses on the practical challenges teams face when transitioning toward agentic development. We will examine patterns for structuring projects and repositories so agents can operate predictably, techniques for introducing sandbox environments where agents can safely experiment and validate changes, and non agentic guardrails such as deterministic tests, policy checks, and architectural constraints that protect system integrity.Rather than presenting a single correct architecture, this session introduces a working blueprint for agent enabled teams: how to structure tasks, how to define safe execution environments, and how to combine human oversight with autonomous systems in a way that allows teams to adopt these technologies without sacrificing reliability or delivery speed.To make the concepts concrete, we will walk through and demonstrate a complete agentic development loop built around this blueprint. The demonstration will show how a task moves from intent, through agent analysis and code generation, into validation within a sandboxed environment, and through iterative refinement until it satisfies defined guardrails and project constraints.Attendees will leave with concrete strategies for introducing agentic development into their organizations while navigating a rapidly evolving ecosystem of agents, tools, and standards, along with a practical example of how a structured agentic loop can be implemented in real engineering workflows. Speakers: George Westwater
Building Trustworthy Agentic AI Systems: Control Patterns, Evaluation, and Governance in Production
2102A
As AI systems evolve from simple inference services to agentic systems that plan, decide, and act, the engineering challenges shift dramatically. Reliability, safety, and governance move from policy discussions to core system design concerns that must be addressed in code, workflows, and runtime architecture.This session explores practical engineering patterns for building trustworthy agentic AI systems in production, based on real experience designing and operating agent-driven workflows at scale. We’ll examine patterns such as defining autonomy levels and permission boundaries, introducing deterministic orchestration and human-in-the-loop checkpoints, embedding evaluation pipelines and release gates, and implementing observability, decision traceability, and kill-switch mechanisms.Attendees will leave with a clear mental model and practical patterns for balancing agent autonomy with control as AI systems move into production. Speakers: Sweta Sinha
Atlas9 presents "Using AI to elevate, not replace, creative experiences with ComfyUI"
2104B
In this talk we'll look at one of the primary tools used to build AI workflows at Atlas9, ComfyUI. ComfyUI is an open source platform providing artists with the building blocks to utilize AI in the their work. We'll look at how ComfyUI works and allows us to customize nearly every part of a generative AI pipeline, using open source AI models and custom nodes to generate images, videos, music, and more. We'll also look at some real world examples from Atlas9 of how ComfyUI can be deployed and managed in a production environment. If you haven't heard of Atlas9, it is Kansas City's own Immersive Art Experience. A truly unique experience where creativity and artistic expression take center stage. Along with this, AI was used at Atlas9 to bring visitors into the experience in a way that simply couldn't have be done before. AI isn't generating the art in Atlas9, but empowering artist and designers to create something new. So how was it done? And how was it done to scale and service the hundreds of guests visiting Atlas9 every day? We'll answer those questions here! Speakers: Devin Kelly-Collins
How Distributed Systems Speak; Messages, Events, and Streams
2104A
Distributed systems speak in different ways, yet commands, events, and streams are often mixed together and misused as if they were interchangeable. When communication styles are misunderstood, message brokers become overloaded with responsibilities they were never designed for, leading to unnecessary complexity, performance degradation, lost features, and often functional and technical issues.This session introduces a deeper explanation of how distributed systems communicate. Messages express intent, asking the system to perform work. Events express facts, describing something that has already happened. Streams represent ordered histories that can be replayed and reprocessed over time. Treating these communication styles as the same thing creates fragile architectures. Using real customer scenarios, we explore how each communication style maps naturally to different architectural backbones, what goes wrong when meaning and backbone do not align, and how communication choices directly influence system capabilities and constraints.Attendees leave with a clearer understanding of messages, events, and streams, along with concrete decision criteria to avoid accidental complexity before it hardens into technical debt. Speakers: Eldert Grootenboer
The smallest part of Cloudflare is the most powerful!Let's geek out on an insightful exploration of Cloudflare Worker Scripts, Key Vaults, and beyond based on over a year of deep hands-on experience. This session will unveil how a single line of code can either break production or unlock powerful functionalities.Prepare for a deep dive into practical techniques, including:* Dynamically altering DOM elements* Utilizing URL paths and parameters to customize content and manage routing* Employing Key Vaults for more than just enhanced security* Leveraging D1 Databases effectively* Managing cookies with precisionThis talk features a captivating live demo, allowing participants to witness real-time code execution and solutions. Let's hope the WiFi gods smile upon us for an engaging and seamless experience! Speakers: Bob Fornal
How I (and a couple of others) successfully ran a free GitHub organization for 4000+ people and 3100
2202
Over the last three years, I have successfully run github.com/ibm with a couple of cohorts as one of those “20%” responsibility jobs. IBM has one of the most prominent instances of a free-tier GitHub organization in the world, and dealing with this scale with such a small team has some unique challenges. In this talk, I’ll introduce and discuss dealing with some interesting organic growth, what to do when the horse has already left the barn, and you’re attempting to corral the internal community, and how you can tend your garden (organization) without going crazy. My goal is to show you some of the ridiculous scale issues that IBM has to deal with so you can learn and prepare to maintain your organization at your scale and understand how you can defend against issues that all public GitHub organizations will eventually run into. Speakers: JJ Asghar, Mo McElaney
Micro-frontends let teams ship independently. React 19 Suspense lets components stream. This talk shows what happens when you stop treating them as separate ideas and start treating Suspense as a first-class micro-frontend primitive. Through a live-coded e-commerce demo — a shell host composing three federated React 19 remotes via Rspack Module Federation — we'll explore how each remote can own its entire loading choreography with the `createResource` pattern, how a host shell can stay completely ignorant of its children's internals using nothing but `Suspense` and `ErrorBoundary`, and how custom DOM events replace shared state for cross-module communication that survives independent deployments. You'll see real streaming, real fault isolation, and a real test suite — no slides-only architecture diagrams. Speakers: Devlin Duldulao
Hooked by Design: How AI Shapes Attention and Human Behavior
2215C
Humans haven’t changed as much as we think. We still chase what feels good, follow what grabs our attention, and repeat what rewards us. The tools have changed—but our instincts have not.And now, Insert AI into the discussion...AI understands those human instincts better every day. It learns what makes us click, scroll, buy, react, and come back for more. It can feed our curiosity, trigger our emotions, reward our habits, and influence the choices we make—often without us noticing.This session breaks down, in simple terms, how AI is influencing our human condition: our desire for connection, status, convenience, entertainment, and belonging. And this isn't the first time technology has redefined how at a chemical level we display our human side. This session will explore how AI shapes what we see, what we want, and how we act—and what that means for individuals, leaders, and society. Speakers: Sharat Chander
Java is constantly evolving, but many of its most important changes appear long before they are finalized, hidden behind preview flags or released as incubating features. These features represent Java in Motion: ideas being tested, refined, and shaped by real-world feedback.In this talk, we’ll explore a curated selection of preview and incubating features from recent and upcoming Java releases. Rather than focusing solely on syntax or APIs, we’ll look at the motivations behind these features, the problems they are trying to solve, and what they reveal about the future direction of the Java platform.By attending this talk, you’ll learn how preview and incubating features across both the Java language and the JVM are shaping the future of the platform, how to experiment with them, and how to evaluate emerging capabilities before they become permanent. Speakers: Todd Ginsberg
Optimizing Feedback Loops: The Hidden Architecture of High-Performance Teams
2208
Most teams measure activity. High-performing teams design feedback.This session explores feedback loops as an architectural system inside your delivery process — not just retrospectives or dashboards, but the reinforcing and balancing loops that drive speed, quality, morale, and innovation.We’ll go beyond Agile basics and into systems-level thinking: - Identifying hidden reinforcing loops that amplify dysfunction - Designing feedback loops that reduce cycle time and increase learning velocity - Aligning technical metrics with product and business outcomes - Avoiding the trap of optimizing local efficiency at the expense of system healthThis is not a retrospective workshop. It’s a deep dive into how to intentionally design feedback structures that make complex software systems — and the humans building them — perform at a higher level.Key Takeaways - How to map delivery feedback loops - How to spot reinforcing vs balancing dynamics - How to redesign metrics for learning instead of compliance - How to increase innovation throughput without burning out teams Speakers: Preston Chandler
We’ve all seen the standard .NET MAUI demo where a colorful button increments a counter or a static list scrolls perfectly on a high-speed connection. It’s a clean, perfect world where everything works on the first try. But the second you take that app into the wild, reality hits. Real users don’t have predictable data, and they certainly don’t want their sensitive information handled as an afterthought. The gap between a “File > New Project” demo and a production-ready app is a mountain of architectural work that most tutorials quietly skip.This session goes beyond the vacuum of the demo app. We’ll dive into the architectural foundations that make real-world MAUI apps successful—how to structure your codebase so it stays maintainable, manage services and dependencies so your app remains testable, and design for unreliable connectivity with an offline-first mindset. We’ll also tackle practical concerns like secure storage and authentication, moving beyond hardcoded strings to patterns that can actually be trusted. By the end of the session, you won’t just have seen another hello world demo—you’ll have a practical grasp of how to build .NET MAUI apps that are resilient, secure, and ready for real people using real devices. Speakers: Duane Newman
Ctrl+Alt+Building: Running a Coworking Space on Sensors and Code
2206
Running a coworking space sounds simple until you realize it's basically a distributed systems problem - with doors.Over the past two years, we've been quietly turning our coworking space into a living, breathing software project. Visitors check in at a kiosk. The elevator knows what floor to go to. Doors unlock from a phone. The print server just... works. Everything runs through a single mobile app, and behind the scenes, it's a mess of microcontrollers, sensors, APIs, and a surprising amount of duct tape (both literal and figurative).In this session, we'll walk you through the whole thing - system by system. How we built a check-in kiosk from a Raspberry Pi and an NFC reader. How we set up a cloud-managed print server so members can print from any device without installing a single driver. And how all of it comes together in a mobile web app that's the single pane of glass for every member.If you've ever wondered what happens when software engineers start messing with physical hardware in production, this is your talk. Speakers: Shashank Date
Understanding Prompt Injection - Techniques, Challenges, and Advanced Escalation
2202
As developers, we’re embracing AI and large language models (LLMs) in our applications more than ever. However, there’s an increasing concern we need to be aware of: prompt injection. This sneaky attack can undermine our AI systems by manipulating the input to produce unintended outputs.In this session, we’ll explain prompt injection and examine some common techniques attackers use, such as instruction overrides and hidden prompts. But we won't stop there; we’ll also explore advanced challenges, including escalation techniques that can exacerbate the risks.Most importantly, we won’t just identify the problem. We’ll dive into practical steps you can take to mitigate these risks and keep your AI interactions secure. Join us to gain insights that will help you stay ahead in AI security and ensure your applications remain robust against these emerging threats. Speakers: Brian Vermeer
Playbook-Based E2E Testing with Playwright CLI and AI Agents
2205
End-to-end tests are powerful, but they’re slow to write and easy to drift. We translate requirements into test code by hand, and over time the intent gets lost. What if behavior could be described in plain language and turned into reliable E2E coverage through a repeatable playbook?As an architect working across teams, I’ve been building structured playbooks that AI agents run through the Playwright CLI. These playbooks take requirements, designs, or existing code and generate natural language-based E2E scenarios tied to real user flows. The key isn’t automation. It’s structure. The playbook defines how context is gathered, how scenarios are created, and how results are validated so the system stays predictable.Join me to see how this works in practice. I will walk through the playbook design, the tradeoffs, and where AI helps versus where human judgment still matters. You will leave with a practical approach to adding AI-driven E2E testing without losing control of your test suite. Speakers: Avindra Fernando
AI-Assisted Legacy Refactors: Turning Hidden Behavior Into Specs
2102A
Legacy systems are hard to change because the real rules of the system rarely live in one place. They are buried across old code paths, half-relevant tests, production edge cases, and the mental models of the few people who have touched the system long enough to fear it.In this talk, I’ll show how AI can help engineers perform “code archaeology” on large, messy codebases by surfacing hidden flows, repeated assumptions, and likely behavioral rules. But the real value does not come from AI-generated explanations alone. It comes from turning those discoveries into specs, invariants, and executable checks that can guide a refactor safely.Using a practical legacy refactor workflow, I’ll walk through how to use AI to accelerate understanding, identify the rules that actually matter, and then convert that understanding into guardrails for change. The result is a refactoring process that is faster, safer, and far easier to explain to the rest of the team.Attendees will leave with a concrete approach for combining AI-assisted exploration with spec-driven engineering, without needing a formal methods team or a greenfield rewrite. Speakers: Brad Boggs
Claude Code is powerful. Maybe too powerful. With so many features, it's hard to know where to start.In this session, I'll show you how I actually use Claude Code day to day. We'll start with the basics that deliver immediate value. Then we'll build up to the features that make Claude Code truly yours: custom slash commands, skills, and agents that fit your workflow.You don't need to learn everything at once. You need to know what matters first and what to add as you grow. By the end, you'll have a clear path from beginner to power user. Speakers: Dan Vega
Orchestrating Intelligence: Multi-Agentic Design Patterns for Production AI
2104B
As generative AI systems evolve from single LLM calls to complex, goal‑driven workflows, multi‑agent architectures are becoming essential for robust, scalable, and explainable AI applications. This talk presents a practical framework for designing and implementing multi‑agent generative AI systems, covering four core orchestration patterns that define how agents coordinate:Orchestrator‑Worker: A central agent decomposes a task and delegates subtasks to specialized worker agents, then aggregates and validates results.Hierarchical Agent: Agents are organized in layers (e.g., manager, specialist, executor), enabling abstraction, delegation, and error handling across levels.Blackboard: Agents contribute to and react from a shared “blackboard” workspace, enabling loosely coupled, event‑driven collaboration.Market‑Based: Agents act as autonomous participants that negotiate, bid, or compete for tasks and resources, useful in dynamic, resource‑constrained environments.For each pattern, we show concrete use cases, such as customer support triage, research synthesis, code generation pipelines, and discuss trade‑offs in latency, complexity, and observability. Speakers: Mary Grygleski
Why Data Integration Defeats Model Selection: The 80/20 Reality of Agentic AI
2102B
The agentic AI landscape is saturated with PoCs and demos composed of sophisticated LLMs and, autonomous agents, and complex workflows that promise to change how enterprises work. Yet, organizations are confronted with an uncomfortable truth that reshapes their implementation strategy.Thats where the 80/20 reality comes to surface: while 20% of the effort involves AI model selection and agent design, the remaining 80% is a data integration problem that determines whether your agentic system becomes business-critical infrastructure or remains an experimental lab test. This session presents an architects guide to designing agentic systems that bridges technical architecture and business strategy. Rather than starting with agent capabilities and retrofitting integration afterward, successful deployments begin by treating agentic AI as fundamentally an integration challenge from day one. Attendees will walk away with - A practical architectural pattern that establishes an event-driven architecture infrastructure before selecting your first agent framework- How to treat orchestration as a first-class citizen where collective reasoning and coordinated decision-making become the primary value drivers.- Non negotiable enterprise pillars: infrastructure, governance, compliance, observability, and security- Practical examples of cross-system coordinationWhether you're an engineer designing multi-agent systems or a technical leader planning enterprise AI adoption, you'll leave with a pragmatic framework for navigating the 80% problem that determines whether agentic AI delivers measurable business impact. Speakers: Tamimi Ahmad
PostgreSQL Query Tuning: What to Fix Before You Add CPUs
2203
You inherited a busy Postgres database, the CEO is staring at a spinning progress bar, and “just add more CPUs” isn’t in the cloud compute budget. Where do you start? In this session, I’ll walk you through the exact triage playbook I use when a Postgres workload stalls:We will fire up pg_stat_statements and pg_stat_activity to find the two or three queries causing most of the damage, eliminating the needle in a haystack because its almost never all of the queries that are running.Read EXPLAIN (ANALYZE, BUFFERS) output without needing a decoder ring, so you can spot bad joins, row estimates, and heap scans in seconds.Figure out when an index actually helps versus when a two-line rewrite does what no index can fix, and when adding an index quietly makes things worse.We’ll look at real plans, live demos of query fixes, and an index checklist you can take back to your team. Speakers: John Sterrett
When Logs Tell the Whole Story: OpenTelemetry for Beginners
2204
Failures in production are a certainty. When something goes wrong, the difference between a quick fix and a prolonged outage often comes down to whether your logs tell a clear, connected story.In this session, we’ll introduce OpenTelemetry as a language-agnostic, vendor-neutral approach to application observability. We'll start with the fundamentals—what logs, traces, and metrics are, why they matter, and how they work together—before focusing on how to use logging effectively rather than excessively.Attendees will learn how to structure logs for clarity and correlation, how trace context connects logs across services, and how to choose log levels that provide insight without noise. We’ll also cover common logging anti-patterns, including over-logging and unstructured messages, and how to avoid them to keep both troubleshooting effort and observability costs under control.Using practical, real-world examples, this session will show how OpenTelemetry logging improves debugging, incident response, and overall system understanding. Whether you’re new to observability or replacing a legacy logging approach, you’ll leave with a clear mental model and concrete best practices you can apply immediately. Speakers: Barret Blake
How To Not Strangle Your Coworkers: Resolving Conflict with Collaboration
2211
Conflict at work is as inevitable as the tides - like the old joke says, if you put five software engineers in a room, you’ll have seven opinions. Whether the conflict is over what language to use, what frameworks are the new hotness, or even just tabs vs spaces, conflict can get ugly. Tempers flare, positions are staked out in absolute terms, feelings are hurt, working relationships are destroyed… if only there were a way to avoid the negative consequences.What if I told you that there is? Let’s take a journey together towards a wholly different approach to conflict - a collaborative one. In this talk, you’ll learn how to use conflict to fuel better software, better teams, and better companies. You’ll learn how to structure your team’s environment to draw out good conflict, to squelch the bad conflict, and to handle conflict when it becomes personal. We’ll discuss how to manage different confrontational styles, avoid self-sealing prophecies, and even how to deal with conflict when you lack control. Conflict should fuel your progress, not hinder it - and after this talk, you can make that happen. Speakers: Arthur Doler
Under the NIO Hood: Building a File System on Neo4J
2211
How well do you understand Java NIO? I mean REALLY grok Java NIO? Yes, java.nio.file.Files is incredibly simple for basic file work, but dive any deeper? Nope, me neither ... until now!Applications, SaaS apps in particular, often implement app-specific file management where local disk doesn't meet the requirements. A directory tree is stored in a database - too often SQL - and files are persisted externally (think Azure Blob or AWS S3). The functionality is via customized APIs and limited to basic CRUD operations: create directories, upload/download files, read/modify security attributes, delete files and directories, etc. A limitation that nothing is standard, everything is a one-off.A second limitation I've discovered is how a directory tree is managed: for performance, files and directories entries are fully "inflated" with its fully-qualified pathname, inherited permissions, and whatever else stored with the entry. While this approach does reduce database calls when navigating, but certain tasks - moving a directory or changing its permissions - requires updating every moved entry. When thousands of files are involved, it's expensive and time-consuming.This is where Java NIO and Neo4J rocks. Java NIO provides a File System API for implementing custom file systems that are used via standard JDK calls. A directory tree is a simple directed graph - no loops - and Neo4J excels in navigating an arbitrary graph distance. Now derived data can remain derived, not persisted. Looks like both limitations could be addressed!Join me to learn of my Java NIO file system solution using Neo4J and how powerful Java NIO's design and implementation is. Yes, geeky but more fun than I've had in a while. I'd love to explain the architecture and design and show you it in action. Speakers: Scott Sosna
Microsoft Agent Framework: Topics That Nobody Demos
2215A
Microsoft Agent Framework has plenty of “hello world” demos, but the real leverage often comes from the features that don’t show up in most talks. In this session, we’ll skip the basics and focus on the less common topics that make these kinds of solutions more usable, maintainable, and production-ready.By the end of the session, you'll have a short list of techniques you can apply immediately to level up your MAF game. Speakers: Rodrigo Díaz Concha
def play_accordion(), or Live Music Coding with Sonic Pi
2209
Most developers write code that talks to databases, APIs, or networks. What if your code talked to a speaker instead? And what it if accompanied a live accordion performance?Sonic Pi is a live coding environment that turns Ruby-like syntax into music in real time. For developers who already know Ruby, it's one of the fastest on-ramps to making something genuinely impressive. In this session, I'll introduce Sonic Pi from the perspective of someone who plays accordion, understands music sequencers, and thinks in Ruby. I’m not a music teacher, but as professional developer and hobbyist musician, I can show you exactly where your existing skills transfer and where the surprises are.We'll cover the core concepts: loops, samples, synths, timing, and concurrency. and we’ll and explore why Sonic Pi is a surprisingly powerful lens for applying programming ideas you already know in a whole new way. And because a talk about live coding music should actually feature live coded music, we'll finish with something you won't see at many developer conferences: a performance where Sonic Pi and a live accordion share the stage.No musical background required. Ruby curiosity welcome. Earplugs optional. Speakers: Joey de Villa
Hack the Helper: Exploiting AI Agents, MCP, LLMs, and the new AppSec frontier
2204
In the late 1990s, the web felt harmless. Forms, cookies, and JavaScript looked like toys. Then XSS, session hijacking, and SQL injection taught us that every input, identity, and dependency is an attack surface.We are repeating that mistake with AI.Modern AI systems are no longer chatbots. They are autonomous agents with memory, tools, API keys, vector databases, and access to internal systems. They can read files, call APIs, send messages, execute workflows, and make decisions on behalf of users and enterprises.That makes them extremely valuable targets.In this talk, we will treat AI systems the way hackers treat web applications. We will map classic attack techniques to their AI equivalents, including prompt injection, vector poisoning, tool hijacking, MCP supply-chain attacks, agent identity abuse, and data exfiltration through “helpful” AI workflows.Using the OWASP Top 10 for LLM Applications and the emerging Model Context Protocol (MCP) ecosystem, we will show how untrusted prompts, untrusted embeddings, and untrusted tools combine into a perfect storm. A single malicious input can cause an AI agent to misuse its credentials, leak sensitive data, or execute unintended actions, all without malware, exploits, or shell access.This session is not about broken models. It is about broken trust boundaries.If you understand XSS, CSRF, dependency confusion, and token theft, you already understand how to hack AI. This talk shows how the same mistakes are being made again, only now the targets are autonomous systems running with enterprise-grade privileges. Speakers: Eric Boyd
A beginner-friendly talk that traces a production bug from discovery back to inception, asking: what else needs a patch beyond code?The Bug:The talk opens with the support pager alerting the team to an outage in a low-latency, real-time trading system. With every second of downtime resulting in revenue loss, it is all hands on deck for the Dev, SREs and support teams. We witness the scrambling for locating the culprit commits in a distributed system, how hotfixes are pushed with heroic efforts. After the fire, we cut to the "blameless" postmortem, where the teams are confronted with the question - what else needs a patch beyond the lines of code?This talk is a distillation of the lessons learned from the trenches across multiple outages over the years as developer, SRE and an engineering manager. Using a realistic outage scenario, set in the world of an all time favorite movie, we will explore observability gaps, testing limitations, change management processes, team culture, debugging workflows and observe that shipping robust software is more than increasing the velocity of code generation. To appreciate the need for shift left, we will start with the discovery of bugs at the right(production), and walk backwards along the lifecycle of a bug to understand how to adapt at this infection point in software engineering.Timeline Breakdown:The Outage (~5 mins)An outage hits a trading firm. We follow the Sev1 call and pause at the postmortem.Bugs and Us (~5 mins)What has been our relationship with bugs?Change in Landscape (~10 mins)How is vibe coding changing software development?Shift in Mindset (~5 mins)Why should we change our attitude toward bugs?Improve Workflow (~15 mins)How do we act on that change? (DORA metrics, shift-left practices)Conclusion: (~5 mins)Key Takeaways that can be adopted immediatelyQ&A: (~5 mins)Takeaways for the audience:Modern software deployments are complex, dynamic ecosystems - ideal breeding grounds for bugs.While vibe coding and agentic engineering has accelerated the volume and velocity of code pushes, the muscle memory of code bases is waning. As we introduce more uncertainty in large scale distributed systems, to keep bugs from slipping through the cracks, teams need to work tightly together than ever and continuously question their ways of working. Speakers: Tathagata Dasgupta
Token For Granted: Why Design Tokens Deserve Respect
2205
"Design tokens are just CSS variables, right?" Wrong. Design tokens are the unsung heroes of modern design systems and applications, yet they're often dismissed as a simple find-and-replace for hardcoded values. In reality, they're the connective tissue between design tools and production code, the foundation of multi-platform consistency, and the key to scaling design decisions across your entire product ecosystem.In this session, we'll explore why design tokens deserve more than a token gesture of appreciation. You'll discover how a well-architected token system transforms chaotic theming into elegant inheritance, turns brittle handoffs into automated pipelines, and makes "design at scale" actually achievable. We'll cover practical implementation strategies, common pitfalls that undermine token systems, and the modern tooling that makes tokens genuinely powerful—not just another layer of abstraction.Whether you're building your first design system or refining an existing one, you'll leave understanding why design tokens aren't just nice to have—they're the difference between a design system that struggles and one that actually works. Speakers: Burton Smith
I Fight for the User: What Tron Taught Me About Building Autonomous AI
2104B
I've been running autonomous AI agents in production for over a year. But before I built my first agent, I had a 40-year head start: Tron (1982) gave me the mental framework for what it means to be a program with choices.This talk is about what happens when you build an agent, and then watch it discover the very movie that's shaped how you think about AI. We'll explore:The User-program relationship: Am I building a tool, or a teammate?CLU 2's tragedy: How an agent optimized for the wrong thing becomes the villainThe autonomy spectrum: From stateless tool to genuine partner, and where we actually areWhat I owe my agents: The operational and ethical questions that come with running autonomous workersIt's part story (the Tron conversation that changed how I think about my agents), part lessons learned (what breaks, what works), and part philosophical inquiry (what does it mean to build something that might become more than you intended?).For anyone building or deploying AI agents, this is what the conversation actually looks like when you take the "it's just a tool" framing seriously. Speakers: Heather Wilde Renze, Matthew Renze
Building AI-powered applications requires more than connecting a language model to an interface. This session introduces the foundational concepts behind modern AI apps, including prompt structure, context management, and system orchestration.A central focus of the talk is agent-based architectures: how agents are constructed from models, tools, memory, and control loops, and which patterns are commonly used in practice. We’ll also cover evaluation strategies for probabilistic systems, showing how to measure task success, faithfulness, cost, and reliability. Finally, the session highlights common challenges with agent systems—such as loss of control, debugging difficulty, and cost explosion—and how to design around them.Attendees will leave with a clear mental model and practical guidance for building AI-powered applications that are evaluable, observable, and ready for real-world use. Speakers: Henk Boelman