Chris Woody Woodruff
Architect at Real Time Technologies
Grand Rapids, Michigan, United States
Actions
Chris Woodruff, also known as Woody, is an Architect at Real Time Technologies and brings nearly three decades of industry expertise, having launched his career before the first .COM boom. Renowned for his contributions to software development and architecture, Woody is a regular speaker at international conferences, where he shares his deep knowledge on topics ranging from database development to APIs and web technologies. He is a Microsoft MVP in the areas of .NET and Web Development.
A dedicated mentor, Woody thrives on guiding fellow developers and enhancing their skills through his talks, written work, and digital content. He co-hosts the popular "Breakpoint Show" podcast and YouTube channel, which he uses to connect with and educate the tech community. He is also writing a book covering network programming with C# and .NET.
Woody's interests extend beyond his professional life, adding a personal touch to his character. He is a passionate bourbon enthusiast, often embarking on adventures along the Bourbon Trail in search of unique finds to savor and share with friends. Family time is a cherished part of his life, and he often shares insights from his professional journey on his blog at https://woodruff.dev. To stay updated on his latest projects and adventures, follow him on Twitter at @cwoodruff and Mastodon at https://mastodon.social/@cwoodruff, where he shares his thoughts and experiences, fostering a sense of connection with his audience.
Badges
Area of Expertise
Topics
Entity Framework Core in Action: Building High-Performance, Production-Ready Data Layers w/.NET 10
EF Core is more than just an ORM; it's a foundational piece of any scalable, modern .NET application. However, many developers only cover basic CRUD and leave performance, security, and scalability untapped.
In this deep-dive, full-day hands-on workshop, you’ll master Entity Framework Core by building a complete order management system designed for real-world performance and maintainability. We'll start with proper modeling, walk through powerful LINQ queries, optimize using execution plans, and secure every data pathway. You’ll go beyond the basics to manage relationships, implement caching, use raw SQL safely, and prepare your data layer for distributed, cloud-based environments.
Whether you're working with Minimal APIs, Razor Pages, or ASP.NET Core Web API, this workshop will elevate your EF Core knowledge from “it works” to “it flies.”
Who Should Attend
• Intermediate to advanced .NET developers
• Engineers looking to scale beyond CRUD
• Architects building distributed or cloud-hosted .NET solutions
• Developers struggling with slow queries, N+1 bugs, or data design debt
Prerequisites & Tools
• Experience with C# and .NET Core
• Installed: .NET 10 SDK, Visual Studio or Rider, SQL Server (local or cloud), Postman or SSMS
• Sample project and tools provided day-of
Key Takeaways
• Advanced EF Core modeling and querying skills
• Proven techniques for query tuning and diagnostics
• Real-world testing, concurrency, and caching patterns
• Tools for securing your data layer against abuse
• Hands-on experience building and optimizing an enterprise-ready system
Evolutionary AI Programming: Building Adaptive Systems with C# with Genetic Algorithms
When people discuss AI, they often revolve around deep learning and neural networks. However, not all challenges require a GPU and 50 GB of training data. Sometimes, nature already has the answer.
In this session, we will explore Genetic Algorithms (GAs), an evolutionary approach to solving optimization and search problems implemented entirely in C# and .NET. You will learn how these algorithms mimic natural selection to evolve increasingly effective solutions over time.
We will construct a GA engine from scratch, examine encoding problems such as the traveling salesman or scheduling, and demonstrate how mutation, crossover, and fitness functions operate in practice. Throughout the session, we will highlight when GAs are appropriate, how to optimize their performance, and where they can complement or outperform other AI approaches.
Whether you are an AI enthusiast, a .NET developer interested in evolutionary computing, or simply someone who enjoys solving puzzles with code, this talk will introduce you to a powerful yet underutilized technique.
Who Should Attend:
• C# and .NET developers interested in alternative AI techniques
• Engineers solving optimization, search, or scheduling problems
• Developers looking for approachable, lightweight machine learning methods
• Anyone tired of black-box models and interested in transparent algorithmic logic
Key Takeaways:
• Understand the core concepts of Genetic Algorithms: population, fitness, selection, crossover, mutation
• Learn how to implement a working GA engine in C# and .NET
• Explore real-world applications like pathfinding, tuning algorithms, and adaptive behaviors
• Compare GAs to traditional AI/ML methods when to use which
• Get inspiration and resources to build your own evolutionary experiments
Beyond CRUD: Building Secure, Performant, and Scalable APIs with ASP.NET Core 10
Web APIs are the backbone of modern digital experiences, spanning web applications and mobile platforms to cloud services and the Internet of Things (IoT). Yet many developers stop at CRUD operations, leaving their APIs vulnerable, inefficient, and challenging to scale.
In this full-day, hands-on workshop, you’ll move beyond the basics to design and build cloud-ready, production-grade APIs with ASP.NET Core 10. You’ll not only cover foundational concepts like routing, dependency injection, and data access with EF Core, but you’ll also dive deep into real-world security practices (OAuth2, JWT, policies), performance tuning (caching, DI scopes, rate limiting), and scalable API architecture patterns (repository/unit-of-work, versioning, clean layering).
You’ll build an eCommerce-style API together from scratch, complete with secure user access, protected order management, and rich client-side consumption techniques. You'll walk away confident in your ability to deliver APIs that are not only functional but also hardened, testable, and ready for the cloud.
Who Should Attend
Intermediate to advanced .NET developers seeking to enhance their API skills by focusing on security, performance, and real-world best practices for scalable systems.
Prerequisites & Requirements
Attendee Knowledge:
• Comfortable with C#, .NET, EF Core, LINQ, and MVC/Web API
Tools to Bring:
• .NET 10 SDK + IDE (Visual Studio, Rider, or VS Code)
• SQL Server (local or cloud instance)
• Postman or Fiddler
• Git
Key Takeaways
• Build bulletproof APIs with security baked in from the start
• Use ASP.NET Core 10’s latest features to create minimal, maintainable code
• Master JWTs, OAuth2, and role/claims-based authorization
• Implement DI, versioning, and performance patterns for scalability
• Confidently test and debug your APIs using modern tools
• Know how to integrate APIs with real client-side apps
Modern UX Without JavaScript Madness (Workshop)
Say goodbye to bloated frontends and client-side chaos. In this workshop, you'll discover how htmx and ASP.NET Core enable you to build fast, modern, and interactive web apps without relying on a full SPA framework. Through hands-on labs and real-world examples, you’ll learn to enhance Razor Pages and MVC with htmx-powered features such as real-time validation, partial updates, dynamic forms, and smooth UX patterns, all while keeping the logic on the server where it belongs. This is not just a tooling demo; it’s a new mindset for building user interfaces: one that prioritizes simplicity, performance, and developer happiness.
What You’ll Learn:
• How to use htmx to add dynamic behaviors without writing JavaScript
• Integrating htmx with ASP.NET Core Razor Pages or MVC
• Building interactive forms, live search, and modal dialogs
• Managing state, history, and partial updates efficiently
• Designing real-world UI flows with server-rendered interactivity
Who Should Attend:
• ASP.NET Core developers looking to build richer UIs without switching to React or Blazor
• JavaScript-fatigued engineers who want simplicity without losing interactivity
• Architects and technical leads exploring modern UI strategies with less overhead
• Frontend-leaning devs curious about htmx’s growing popularity in server-side apps
Requirements:
• Laptop with .NET SDK 7 or later (8 preferred)
• Visual Studio 2022 or VS Code
• Basic knowledge of Razor Pages or MVC
• Comfortable with HTML and C# (JavaScript is optional seriously)
Format:
• Full-Day Hands-On Workshop (6 hours + breaks)
• Optional 2-Hour Introductory Session available for conferences with tighter schedules
Terraform in the Real World: Lessons from the Cloud Trenches
Provisioning cloud infrastructure may seem straightforward until challenges arise, such as broken state files, disorganized modules, and environments that become out of sync. In this fast-paced, practical session, you’ll learn how to move beyond the Terraform “hello world” to write Infrastructure as Code that scales, endures, and supports teams.
We’ll examine real-world Terraform techniques for modularization, state management, environment isolation, and team collaboration, all with an emphasis on reliability and maintainability. Whether you're deploying to Azure, AWS, or both, this talk provides patterns and anti-patterns drawn directly from production environments, along with battle-tested tips to help you sidestep costly mistakes.
If you’ve used Terraform before or plan to shortly and want to write IaC with confidence, this talk will equip you with the tactical and strategic skills you need to succeed.
Key Takeaways:
• How to structure your Terraform code for reuse and clarity with modules and workspaces
• Understanding state: remote backends, locking, and why local files are a trap
• Techniques for multi-environment deployment (dev, staging, prod)
• Handling secrets, provisioning steps, and common gotchas in cloud automation
• Tips for integrating Terraform into CI/CD with tools like GitHub Actions or Azure DevOps
• Code patterns that scale and ones that don’t
Target Audience:
• Cloud engineers and DevOps practitioners tired of hacking Terraform together
• Developers transitioning into infrastructure responsibilities
• Architects designing scalable IaC solutions across teams
• Anyone ready to stop treating Terraform like bash scripts and start treating it like software
From C# to Rust: A Developer’s Journey Into Performance, Safety, and Sanity
What happens when a lifelong C# developer falls down the Rust rabbit hole? In this honest and practical session, we’ll explore the journey from managed memory and runtime comforts to the fiercely safe and incredibly fast world of Rust. You’ll get a firsthand look at how Rust challenges the habits of a .NET developer and improves your skills in the process. From ownership and borrowing to traits and lifetimes, we’ll demystify what makes Rust unique and why it's worth learning, even if you love C#.
Through real-world comparisons and live code demonstrations, you’ll discover how Rust’s focus on memory safety, concurrency, and performance provides new advantages for tackling problems that managed runtimes sometimes struggle with. Whether you're curious about Rust, focused on performance, or just want to explore what’s possible beyond the CLR, this talk will provide you with a fresh perspective, valuable insights, and a roadmap for incorporating Rust into your development toolkit.
Who Should Attend:
• C# and .NET developers curious about Rust and systems programming
• Engineers looking for safer, faster alternatives to native C++ interop
• Architects evaluating language choices for performance-critical applications
• Polyglot programmers exploring how Rust fits into cloud, backend, and CLI tools
Key Takeaways:
• Understand Rust’s ownership model and why it matters
• Compare C# constructs with Rust equivalents through real code
• Learn how to port .NET-style APIs to idiomatic Rust
• Discover how Rust avoids data races without a garbage collector
• See where Rust fits (and doesn’t fit) in a .NET-centric architecture
• Leave with practical resources for learning and applying Rust as a C# developer
Queryable by Design: Supercharge Your APIs with OData and .NET
Most REST APIs deliver fixed endpoints with rigid filters, but what if your clients could shape the data they need without dozens of bespoke query parameters? In this practical, eye-opening session, you'll discover how OData allows you to build flexible, discoverable, and queryable APIs using the full power of .NET and ASP.NET Core.
We’ll start by breaking down what OData is (and isn’t), then dive into how to implement OData in modern .NET applications. You’ll learn to expose APIs that enable clients to use $filter, $expand, $orderby, and more, facilitating smarter queries, reducing payloads, and giving front-end developers superpowers.
However, this talk goes beyond the basics. We'll explore real-world performance strategies, how to integrate OData cleanly with EF Core, and the architectural decisions behind when (and when not) to use it. If you’re building APIs that deal with complex or hierarchical data, this session will help you architect for flexibility and future scalability.
Who Should Attend:
• .NET developers building or maintaining data-rich REST APIs
• Backend engineers looking for more flexible querying without writing dozens of endpoints
• API architects and tech leads focused on reusability, performance, and long-term maintainability
• Front-end or mobile developers interested in shaping API responses more precisely
Key Takeaways:
• What OData really is and how it enhances API capabilities
• How to add OData to an ASP.NET Core Web API and expose EF Core data with rich query support
• Real-world use of $filter, $orderby, $top, $expand, and more
• Best practices for securing, optimizing, and documenting OData APIs
• When to use OData and when it might be the wrong fit
• Performance tips: pagination, caching, and server-side limits
REST Reimagined: Unlocking Discoverability with HATEOAS in ASP.NET Core 10
Most APIs expect clients to read the documentation, hardcode routes, and manage fragile logic when changes occur. But what if your API could guide the client through valid actions, just like a user interface guides a user?
In this session, we’ll explore how to enhance your ASP.NET 10 Web API using Hypermedia, the unsung hero of REST. You’ll learn what it means to design APIs that explain themselves, utilizing links and actions embedded in the response to dynamically describe what’s possible next.
We’ll unpack HATEOAS (Hypermedia as the Engine of Application State) from the ground up: what it truly signifies, why it’s powerful, and how to implement it in .NET through real-world examples. You’ll come away understanding how to build APIs that are more discoverable, adaptable, and client-friendly without bloating your codebase or breaking your users.
Who Should Attend:
• ASP.NET Web API developers looking to improve API usability and client flexibility
• Architects and tech leads aiming to evolve API designs without breaking consumers
• Backend engineers exploring REST maturity, HATEOAS, and client-driven workflows
• Anyone building APIs who’s tired of maintaining brittle, tightly coupled documentation
Key Takeaways:
• What Hypermedia is (and what it’s not), and why it matters in REST API design
• How to implement Hypermedia affordably in ASP.NET 10 Web API
• When and where to use HAL, Siren, or custom hypermedia formats
• Real-world examples of making APIs self-descriptive using links and actions
• Strategies to evolve APIs safely by guiding clients through discoverable actions
• Common myths and trade-offs: when Hypermedia helps and when it doesn’t
Cache Me If You Can: Tuning Web API Performance with ASP.NET 10
Your API is only as good as its speed. Slow endpoints lead to frustrated users, increased infrastructure costs, and scalability challenges. Fortunately, caching can be your secret weapon if you know how to use it effectively.
In this practical, code-rich session, you'll learn how to implement smart caching strategies in ASP.NET 10 Web API to deliver lightning-fast responses without compromising data accuracy or maintainability. We’ll cover everything from in-memory and distributed caches to response caching, cache invalidation patterns, and real-world scaling scenarios.
Whether you're building public APIs, internal services, or anything in between, this talk will equip you with the knowledge to design fast, reliable, and cost-effective APIs while avoiding the common pitfalls that can make caching seem more challenging than it needs to be.
Who Should Attend:
• ASP.NET Core Web API developers looking to optimize app performance
• Backend engineers handling high traffic or scaling systems
• Architects designing APIs for reliability, speed, and cost efficiency
• Devs tired of slow response times and over-complicated cache setups
Key Takeaways:
• The “why” behind caching: performance, resiliency, and scale
• Implementing in-memory, distributed, and response caching in ASP.NET 10
• Avoiding stale data: cache expiration, sliding windows, and invalidation strategies
• How to choose the right cache (MemoryCache, Redis, etc.) for your use case
• Caching API responses, database calls, and expensive operations
• Best practices for cache organization, observability, and fallbacks
Eco-Driven Architecture: How .NET 10 Can Help You Build Greener Apps
What if performance and sustainability weren’t competing goals, but rather partners? As our software shapes the world, we bear a growing responsibility to create systems that are energy-efficient, resource-conscious, and environmentally aware. In this session, we’ll explore how to design and implement green software architectures utilizing the modern features of .NET 10.
You’ll learn how to reduce your application’s carbon footprint by making smarter architectural decisions, choosing efficient frameworks and patterns, optimizing compute and network usage, and embracing cloud-native design. We’ll highlight how new .NET capabilities, from improved runtime efficiency to serverless integration, can assist teams in building fast, scalable, and more sustainable systems.
This talk isn’t about wishful thinking; it’s about practical, measurable changes that generate impact. Whether you're developing cloud apps, APIs, or desktop systems, you'll walk away with actionable insights to make your solutions greener and your engineering more intentional.
Who Should Attend:
• Software engineers and architects interested in sustainable software practices
• .NET developers looking to improve energy efficiency in their apps
• Technical leads working on cloud-native, distributed, or high-scale systems
• Decision-makers seeking to align engineering with ESG or corporate sustainability goals
Key Takeaways:
• Understand the principles of green software: energy usage, efficiency, and environmental impact
• Identify key architectural patterns that reduce energy and resource consumption
• Leverage .NET 10 features like AOT, minimal APIs, and improved GC for performance and sustainability
• Analyze trade-offs between compute cost, speed, and sustainability in system design
• Build cloud-native .NET apps that scale efficiently using containers, functions, and autoscaling
• Learn tooling and techniques to measure energy and performance impact
Build Once, Speak to the World: Globalizing ASP.NET Apps for a Multilingual Audience
If your application only supports one language, you're already leaving users behind. In today’s interconnected world, building apps that adapt to users' languages, cultures, and expectations is not a luxury; it’s a necessity. In this session, you’ll learn how to build globally aware web applications using ASP.NET 10.
We'll explore the complete internationalization (i18n) toolkit, including built-in localization services, dynamic culture switching, UI adaptation, and scalable globalization strategies. You’ll discover how to translate strings, format dates and currencies according to locale, and create culture-specific content without reinventing the wheel.
Whether launching globally on day one or expanding into new markets later, this talk equips you with the tools and architectural patterns needed to build respectful, responsive, and inclusive ASP.NET apps that thrive across borders.
Who Should Attend:
• ASP.NET developers building products for users beyond a single locale
• Frontend/backend engineers tasked with localizing UI and APIs
• Product teams preparing for international expansion
• Architects and tech leads responsible for building scalable and accessible web platforms
Key Takeaways:
• Understand the differences between globalization, localization, and internationalization in .NET
• Implement ASP.NET 9’s built-in localization middleware and services
• Dynamically serve content in the user’s preferred language and cultural format
• Handle number, date, and currency formatting across locales
• Enable runtime language switching and fallback strategies
• Explore real-world architectural patterns for localization at scale
• Identify common internationalization mistakes and how to avoid them
Behind the LINQ: Diagnosing What EF Core Is Really Doing to Your Database
Your Entity Framework code looks clean. Your LINQ queries compile. However, your app is lagging, and users are noticing. The mystery? It's what occurs after your query hits the database.
In this fast-paced, investigative session, you’ll become a performance detective, learning how to trace, debug, and optimize what Entity Framework Core does behind the scenes with SQL Server. We'll demystify common EF Core performance killers like implicit joins, unintentional N+1 problems, and bloated queries, showing you how to catch them red-handed using SQL Server tools.
You’ll leave with a solid understanding of how to analyze SQL queries generated by EF, interpret execution plans, and utilize SQL Profiler, Query Store, and other diagnostic tools to identify inefficiencies. This session is perfect for developers, DBAs, and tech leads who want to write better queries and build faster .NET apps.
Who Should Attend:
• .NET developers using EF Core with SQL Server
• Backend engineers trying to debug slow or confusing data access patterns
• Architects and team leads building high-throughput apps
• DBAs collaborating with dev teams on performance issues
Key Takeaways:
• How Entity Framework translates LINQ into SQL and where it can go wrong
• Real-world causes of bad performance: lazy loading, query overfetching, bad projections
• How to capture and analyze generated SQL using SQL Profiler and Query Store
• Reading and understanding SQL execution plans
• Best practices for fixing common EF query problems (including performance-tuned LINQ)
• How to collaborate effectively between devs and DBAs
SELECT * Must Die: Smarter Queries for Faster, Safer Applications
That innocent-looking SELECT * in your application’s code? It could be quietly tanking your performance, over-fetching data, and making your database suffer. Worse, developers may not even realize the damage they are doing.
In this practical, story-driven session for the database professionals and those who support developers, we’ll dig into the hidden costs of unoptimized queries and the architectural ripple effects of poor ORM usage. You’ll learn why SELECT * is the enemy of performance and maintainability and how to coach your team into writing queries that are lean, explicit, and production-ready.
We’ll explore how ORMs like Entity Framework Core shape database interactions, how to identify and eliminate inefficiencies, and how to create a shared understanding between developers and DBAs that enhances performance and trust. You’ll leave with real-world examples, tuning techniques, and a better strategy for modern, optimized data access.
Who Should Attend:
• Data professionals wanting to improve how they support their developer teammates and their apps that impact databases
• Team leads and architects creating development standards around data access
Key Takeaways:
• Why SELECT * is a bad default and how to replace it with explicit, efficient querying
• How to profile and measure the real impact of query shape on app performance
• Techniques to improve data access using projections, anonymous types, and DTOs
• Common anti-patterns in Entity Framework (e.g., lazy loading, under-specified queries)
• How to build productive Dev–DBA collaboration around performance
• Tools and metrics to monitor and audit query usage over time
Architecting Resilient Web APIs with ASP.NET 10: Patterns for Real-World Success
Building a web API is easy. Building one that lasts, scales cleanly, tests well, and survives real-world change is where the true challenge begins.
In this fast-paced, practical session, you’ll learn how to architect modern, maintainable, and testable web APIs using ASP.NET 10. We’ll go beyond simple controller logic and explore how to design APIs that cleanly separate concerns, embrace domain-driven thinking, and keep data access decoupled from request handling.
You’ll walk away with actionable patterns for layering your APIs, organizing your code for collaboration, and preparing your services for scaling, refactoring, and testing. Whether you're building greenfield systems or untangling legacy endpoints, this talk will help you elevate your ASP.NET 10 API game.
Who Should Attend:
• ASP.NET Core developers designing or maintaining RESTful APIs
• Engineers and tech leads interested in clean architecture principles
• Backend developers frustrated with tangled controller logic and code reuse issues
• Architects seeking a lightweight yet structured approach to API development
Key Takeaways:
• Design APIs using layered architecture: Controllers, Application Layer, Domain Layer, Data Layer
• Use Dependency Injection and Abstraction to isolate and swap implementations
• Apply DTOs and ViewModels to enforce API boundaries and shape responses
• Implement unit and integration testing strategies for real-world API coverage
• Explore clean API routing, validation, and behavior reuse with filters and middleware
• Understand how to organize folders, projects, and services for scalable growth
Entity Framework Core Secrets: 10 Insights That Will Change How You Code
Many developers use Entity Framework Core daily, but few fully harness its potential. Behind the simple LINQ queries and DbContext lies a powerful data access engine that can either enhance your app's performance or quietly undermine its scalability and maintainability.
In this engaging and fast-paced session, we’ll unveil 10 essential things every developer should know about EF Core but probably doesn’t. You’ll learn how to write faster queries, steer clear of common pitfalls, use advanced features effectively, and debug your data access with expertise.
Filled with real-world examples, performance insights, and lesser-known capabilities, this talk will empower you to stop struggling against the framework and begin mastering it. Whether you're new to EF Core or have years of experience, you’re sure to leave with valuable insights to enhance your next project.
Who Should Attend:
• ASP.NET and .NET developers using Entity Framework Core in production
• Backend engineers frustrated with slow queries or unpredictable behavior
• Architects creating data access layers and optimizing performance
• Developers transitioning from EF6 or other ORMs to EF Core
Key Takeaways:
• Why AsNoTracking() can be a hidden superpower (or a silent bug)
• How lazy loading, change tracking, and query composition really work
• The impact of Include() on performance and how to control it
• Smart ways to write projections that scale
• Hidden features like compiled queries, raw SQL, and interceptors
• What’s happening under the hood with migrations, contexts, and DI
• Tips to avoid common mistakes like context lifetime issues and N+1 queries
• How to debug EF Core queries with SQL Profiler, logging, and query plans
• Understanding batch execution and transaction scope behaviors
• When EF Core is the right tool and when it’s not
From Chaos to Control: Getting Serious with Entity Framework Core Migrations
Too many teams treat Entity Framework Core Migrations as a magic button until their schema becomes out of sync, their history breaks, or production deployments become daunting. Does this sound familiar? In this session, we’ll break down what developers misunderstand about EF Core Migrations and show you how to use them correctly.
You’ll learn how migrations operate behind the scenes, how to version and manage them across different environments, and how to prevent disasters caused by poor practices or misconceptions. We’ll explore real-world examples of messy migrations gone wrong and how to rectify them.
You’ll also acquire practical strategies for collaborating across teams, working with DBAs, and utilizing EF Core Migrations in modern CI/CD workflows. This is the session that will save your team weeks of effort and pain.
Who Should Attend:
• .NET developers using EF Core for real-world applications
• Engineers working in teams or with DevOps pipelines that deploy to shared databases
• Architects looking to improve development workflows and database safety
• DBAs trying to work more smoothly with EF-powered teams
Key Takeaways:
• How EF Core Migrations actually work snapshot models, metadata, and deltas
• Common mistakes like auto-generating everything or overwriting migrations
• When to script migrations manually and when to trust the tooling
• Handling multiple developers and environments without stepping on each other
• Strategies for clean rollback, seeding, and database initialization
• Integrating Migrations into CI/CD without surprises in production
• Patterns for using EF Core with legacy or production-first databases
Turbo-Charging Entity Framework Core 10 for Speed and Scale
Entity Framework Core 10 is powerful, but by default, it's not fast. Performance problems often hide beneath clean-looking LINQ, only to surface as slow queries, bloated responses, and overloaded databases.
In this session, you’ll learn how to optimize EF Core for performance without sacrificing the productivity it offers. We'll discuss the tools, patterns, and internal mechanisms that enable you to write efficient, scalable queries, minimize unnecessary database round-trips, and avoid common pitfalls that hinder real-world applications.
Through live demos, benchmarks, and hard-earned lessons, we’ll cover everything from compiled queries and projections to query plans and connection pooling. You’ll leave with the knowledge to enhance your EF Core data layer for significant speed, whether you're building APIs, background services, or high-volume systems.
Who Should Attend:
• ASP.NET and .NET developers using EF Core in production
• Backend engineers working with large datasets or real-time data access
• Architects responsible for application performance and scalability
• Developers frustrated with LINQ that looks good but runs slow
Key Takeaways:
• Why LINQ isn’t always your friend and how to write faster queries
• How to use compiled queries, selective projections, and batching
• Avoiding N+1 problems, overfetching, and lazy-loading traps
• Reading and interpreting SQL execution plans to find real bottlenecks
• Using caching and connection optimizations for high-load environments
• Logging and diagnostics with EF Core’s performance tooling
• When EF Core is not the right choice and what to use instead
Simplicity by Design: Rethinking Web Interactivity with ASP.NET Core and htmx
Do we really need a JavaScript framework to create a modern, interactive web app? Not anymore. In this talk, you’ll discover how htmx revitalizes ASP.NET Core Razor Pages, empowering you to build dynamic, fast, user-friendly interfaces without reaching for React, Angular, or Blazor. We’ll demonstrate how htmx allows your server to excel at rendering HTML while enhancing it with rich user interactions using just a dash of declarative attributes.
Through real-world examples, you'll learn to implement features like live validation, dynamic forms, partial page updates, modals, and more. We’ll also discuss the performance, maintainability, and developer satisfaction benefits of this simplicity-first approach.
If you're weary of frontend complexity and just want to create clean, powerful web apps, this talk will show you how Razor Pages + htmx is a groundbreaking combination.
Who Should Attend:
• ASP.NET developers looking for a modern UI approach without full SPAs
• Backend engineers wanting to deliver better UX with minimal frontend hassle
• Developers curious about htmx, progressive enhancement, and hypermedia
• Anyone frustrated with bloated JS build pipelines and over-engineered UI stacks
Key Takeaways:
• What htmx is, how it works, and why it fits Razor Pages like a glove
• How to add interactivity with hx-get, hx-post, hx-trigger, and hx-swap
• Building modals, live validation, and progressive UIs using server-side rendering
• Using partial Razor views and smart endpoints for clean, reusable components
• Debugging htmx interactions and managing client-server flow
• The Simplicity-First philosophy and how it leads to faster delivery and happier teams
Simplicity Is Sustainable: Building Greener Software with Less
Modern software demands are outpacing our infrastructure, budgets, and increasingly, our planet. While we focus on microservices, orchestrators, and the latest framework trends, we often overlook a powerful principle that saves energy, time, and sanity: simplicity.
In this talk, we explore how the Simplicity-First philosophy directly supports sustainable software development. You’ll learn how reducing architectural complexity leads to lower energy consumption, longer hardware lifespans, and clearer visibility into performance bottlenecks. Through real-world examples, we’ll break down how simple design choices—leaner APIs, fewer dependencies, and streamlined deployment pipelines—can reduce carbon emissions and operational costs without sacrificing user experience or scalability.
You’ll leave with practical insights for building sustainable systems that not only operate more efficiently but are also easier to understand, maintain, and evolve. Because the cleanest software isn’t just fast; it’s simple.
Learning Objectives:
• Understand the intersection between Simplicity-First architecture and green software engineering.
• Identify software design and infrastructure choices that drive unnecessary energy consumption.
• Learn patterns that reduce cognitive and compute complexity without compromising features.
• Discover how simplicity promotes hardware longevity, efficient testing, and sustainable DevOps.
The Simplicity Code: Designing Intelligent Architecture Without the Buzzwords
Behind every system that’s easy to scale and evolve is an architecture built on clarity, not complexity. But in a world obsessed with Kubernetes YAMLs, CQRS pipelines, and architecture diagrams that require their own legends, simplicity often gets buried beneath layers of abstraction.
This talk introduces a Simplicity-First approach to intelligent software architecture. We’ll explore how simple, intentional design choices lead to systems that are scalable, resilient, and easier to change—not because they rely on the latest buzzwords, but because they embrace timeless principles: separation of concerns, clean interfaces, evolutionary change, and empathetic design.
We’ll dissect real-world architectures, uncover where complexity quietly creeps in, and walk through how to align technical decisions with business adaptability. Whether you’re modernizing a legacy system or building a cloud-native platform, this session will help you chart a clear path forward.
Learning Objectives:
• Understand how Simplicity-First thinking leads to architectures that are scalable, maintainable, and adaptable.
• Learn how to detect and eliminate unnecessary architectural complexity through design reviews and code patterns.
• Discover patterns like modular monoliths, message-based communication, and evolutionary change that support long-term sustainability.
• Shift architectural conversations from “how clever is this?” to “how clear is this?”
Pitch Simpler, Ship Smarter: Selling Simplicity to Stakeholders and Investors
You've built the right architecture. It’s clean, lean, and future-ready. But when it comes time to secure funding, gain buy-in, or prioritize efforts, it often gets lost in translation. The truth is, great systems don’t win hearts (or budgets) unless they’re presented with clarity and business focus.
This talk serves as your tactical guide for selling Simplicity-First solutions to non-technical decision-makers. Whether you're presenting to executives, investors, or product leads, you'll learn how to connect architectural clarity to business value, cutting through the noise of buzzwords and overpromises.
We’ll explore how to communicate complexity reduction as risk mitigation, frame minimal design as operational efficiency, and tell stories that transform boring diagrams into business momentum. You’ll leave ready to make your next architecture pitch land with confidence and maybe even secure that budget increase.
Learning Objectives:
• Translate technical simplicity into stakeholder language: ROI, velocity, risk reduction, and predictability.
• Frame architectural clarity as a strategic differentiator, not a cost-cutting compromise.
• Use storytelling, data visuals, and simplified metaphors to win buy-in without dumbing it down.
• Learn real-world techniques for aligning engineering decisions with investor and executive expectations.
Less Clutter, More Breakthroughs: How Simplicity-First Engineering Fuels Innovation
We often chase innovation by adding more tools, more layers, and more processes. But what if the real breakthrough lies in subtraction? This talk examines how Simplicity-First thinking fosters an environment where innovation can flourish. You'll learn how simplifying decisions, workflows, and system design eliminates the friction that stifles great ideas before they even start.
By cutting through technical, organizational, and cognitive noise, we gain the clarity and speed necessary to respond to market shifts, launch experiments more quickly, and focus on what works. Drawing on real-world product and engineering stories, we’ll reveal how embracing simplicity empowers teams to act decisively, pivot wisely, and seize emerging opportunities that others overlook.
If your team feels trapped in endless meetings, marathon refactoring sessions, or feature gridlock, this talk provides a blueprint for regaining momentum.
Learning Objectives:
• Understand how unnecessary complexity erodes innovation, agility, and team energy.
• Apply Simplicity-First principles to streamline architecture, product design, and team processes.
• Learn frameworks to reduce decision friction and encourage experimentation without chaos.
• Recognize the organizational signals that it’s time to simplify and how to lead that shift.
From Zero to Socket Hero: Mastering Network Communication in C#
Network programming can often seem intimidating due to the low-level nature of socket APIs. However, once you grasp the fundamentals, it becomes one of the most powerful tools in your .NET toolkit. This session provides a hands-on, practical introduction to socket programming in C#, focusing on the essentials of the TCP/IP stack and its relationship with the Socket, TcpClient, and TcpListener classes in .NET.
You will learn how to create a basic server and client from scratch, send and receive data, and manage connection lifecycles using both synchronous and asynchronous operations. Woody will also explore how these foundational elements can be used to build essential network features, such as chat applications or IoT command relays. Additionally, you will learn how to handle disconnections and exceptions gracefully.
Whether your goal is to develop real-time systems, enable peer-to-peer communication, or gain a solid understanding of what occurs beneath higher-level abstractions, this talk will provide you with the clarity and confidence to start building with sockets today.
Key Takeaways:
• Understand how the TCP/IP stack maps to your C# socket code.
• Learn how to create TCP clients and servers using .NET’s networking APIs.
• See how to manage multiple clients concurrently with basic socket patterns.
• Appreciate the difference between low-level sockets and high-level abstractions.
Target Audience:
C# developers with basic experience in .NET looking to understand network communication fundamentals and build their first low-level networked application.
Async All the Way: Writing Scalable Network Code with async/await in C#
Modern network applications must be responsive and scalable, so they should utilize asynchronous programming. This talk will explore how the `async` and `await` keywords can transform blocking network operations into non-blocking, high-performance workflows in .NET. You will learn how to perform asynchronous reads and writes using sockets and streams while effectively managing the execution flow with `Task`, `ValueTask`, and `ConfigureAwait(false)`.
However, Woody will not only focus on the syntax. He will also discuss the practical implications of writing asynchronous code, including avoiding common pitfalls like deadlocks and thread starvation. You will learn how to implement graceful cancellation using `CancellationToken` and how to structure your network code to keep it readable and testable. Whether upgrading legacy code or starting a new scalable service, this talk will provide you with the essential asynchronous patterns and tools for success.
Key Takeaways:
• Write asynchronous network operations using async and await.
• Discover the performance benefits of non-blocking I/O.
• Avoid common async pitfalls like thread pool exhaustion and deadlocks.
• Learn best practices for cancellation, exception handling, and debugging async code.
Target Audience:
Intermediate .NET developers who want to modernize legacy network code or ensure new applications are scalable and performant using async best practices.
Thread Smart: Building High-Performance Network Servers in C#
As your application grows, managing multiple users or simultaneous network connections can become challenging unless you leverage the power of multithreading. This session will introduce you to concurrent network programming, focusing on effectively handling multiple connections using threads, tasks, and the asynchronous programming model. You will learn to manage concurrency safely using synchronization primitives such as locks, SemaphoreSlim, and Monitor, all while minimizing performance bottlenecks.
Woody will guide you in building a robust, multithreaded TCP server capable of accepting and processing multiple client requests in parallel. You will also learn to avoid common issues like race conditions and resource contention. Additionally, the session will cover how to implement SSL using SslStream, ensuring that your multithreaded server is secure by default. This is an essential session for anyone developing network services in .NET who wants to scale efficiently while maintaining reliability.
Key Takeaways:
• Learn how to handle multiple clients using threads and tasks.
• Understand when to use synchronization tools like lock, Mutex, and SemaphoreSlim.
• Explore techniques for managing shared state safely with ConcurrentDictionary.
• Secure multithreaded communication using SslStream.
Target Audience:
.NET developers building network servers or services who want to handle concurrent users safely and efficiently using multithreading.
QUIC and HTTP/3 in .NET: The Future of Fast, Secure Networking
The limitations of TCP are becoming increasingly evident as users demand faster and more reliable experiences, especially in mobile and high-concurrency environments. Traditional transport protocols are starting to feel like legacy bottlenecks. This is where QUIC, a next-generation protocol developed by Google and incorporated into HTTP/3, comes into play.
In this session, Woody will explain QUIC, a UDP-based protocol that offers built-in encryption, low-latency handshakes, multiplexed streams, and connection migration, all at the transport layer. You will learn how HTTP/3 utilizes QUIC to surpass HTTP/2 by eliminating head-of-line blocking and reducing connection setup times. We will provide practical examples in .NET 8 and 9 using Kestrel, HttpClient, and the System.Net.Quic namespace, enabling you to create high-performance web APIs, multiplayer services, or real-time applications with modern transport features.
Expect live demonstrations, code walkthroughs, and insights into why QUIC is faster, more resilient, and scalable. Whether you are streaming gigabytes of data or sending micro-interactions, this represents the future of networking in .NET.
Key Takeaways:
• Understand how QUIC differs from TCP and why it forms the foundation of HTTP/3.
• Learn how to configure and deploy QUIC-enabled ASP.NET Core apps using Kestrel.
• Explore the System.Net.Quic API to build custom QUIC solutions in .NET 9.
• Discover real-world benefits like multiplexing, connection migration, and TLS 1.3 integration.
• Evaluate performance improvements using practical benchmarks and use cases like file transfer, multiplayer gaming, and API calls.
Target Audience:
• .NET Developers building high-performance web APIs, games, or streaming platforms.
• Software Architects exploring modern transport protocols for scalable, real-time applications.
• Cloud Engineers and DevOps needing to understand QUIC’s operational impact on latency, encryption, and fallback compatibility.
• Performance and Security Engineers seeking ways to minimize overhead and maximize throughput in demanding environments.
Fluent in HTTP: Speaking the Right Language Between APIs and Clients
Behind every exceptional and responsive app is a meaningful conversation between the Web API and its clients, all communicated through the universal language of HTTP. However, many developers overlook HTTP’s potential, viewing it simply as a transport mechanism instead of a powerful tool for conveying intent, status, and data flow.
In this session, we’ll unlock the intricacies of HTTP and empower you to design Web APIs that communicate with clarity, consistency, and effectiveness. You’ll discover how to move beyond basic GETs and POSTs, harnessing the full capabilities of HTTP verbs, status codes, headers, and content negotiation. This knowledge will facilitate strong and intuitive interactions between your APIs and their clients, whether they are mobile apps, single-page applications, or IoT devices.
By mastering HTTP, you will significantly enhance the usability, debuggability, and scalability
Who Should Attend:
• Backend developers creating REST APIs with ASP.NET Core, Node.js, or any modern framework
• Frontend/mobile developers who consume APIs and want clearer contracts and fewer surprises
• Software architects who design distributed systems and care about maintainability and performance
• Developer advocates and DevRel professionals helping teams communicate best practices
Key Takeaways
• Understand HTTP as a semantic protocol, not just a data pipe
• Learn how to use verbs, status codes, and headers the way they were meant to be used
• Design APIs that clearly communicate their purpose and constraints
• Improve client development by aligning expectations with HTTP behavior
• Enhance debuggability and observability through better use of HTTP mechanics
Michigan Technology Conference 2024 Sessionize Event
Live! 360 Orlando 2023 Sessionize Event
Beer City Code 2023 Sessionize Event
KCDC 2023 Sessionize Event
DevSum 2023 Sessionize Event
Rome .NET Conference 2023 Sessionize Event
CodeMash 2023 Sessionize Event
Update Conference Prague 2022 Sessionize Event
KCDC 2022 Sessionize Event
DevSum 2022 Sessionize Event
Update Conference Prague 2021 Sessionize Event
Atlanta Code Camp 2021 Sessionize Event
KCDC 2021 Sessionize Event
Code PaLOUsa 2021 Sessionize Event
Code PaLOUsa 2020 Sessionize Event
CodeMash 2020 Sessionize Event
dev up Conference 2019 Sessionize Event
Code PaLOUsa 2019 Sessionize Event
NDC Oslo 2019 Sessionize Event
CodeStock 2019 Sessionize Event
CodeMash 2019 Sessionize Event
dev up Conference 2018 Sessionize Event
Vermont Code Camp 2018 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top