Jonathan "J." Tower
VP of .NET Foundation | 13x Microsoft MVP | Founder & Consultant
Grand Rapids, Michigan, United States
Actions
Jonathan, or J. as he's known to friends, is a founding partner of Trailhead Technology Partners, a custom software consulting company with employees across the U.S., Europe, and South America. He is Vice President of the .NET Foundation, a 13-time recipient of the Microsoft MVP award for his expertise with .NET and AI, and a frequent speaker at software conferences around the world. He doesn’t mind the travel, though, as it allows him to share what he's been learning and also gives him the chance to visit beautiful places like national parks—one of his passions. So far, he's visited 58 of the 63 U.S. national parks.
J. is also passionate about building the software community. Over the years, he has served on several non-profit boards, including more than a decade as president of the board for Beer City Code, Western Michigan's largest professional software conference. Outside of work, J. enjoys hiking, reading, photography, and watching all the Best Picture nominees before the Oscars ceremony each year.
Badges
Area of Expertise
Topics
Warning: Side Effects of AI May Include…
Our industry just swallowed the biggest change to how software gets built in decades. The effects have been amazing. I've been using AI to significantly increase my speed, accuracy, and productivity, but I've also started noticing more negative things show up in myself, my team, and my clients' developers that nobody put on the label.
Side effects can include getting irritated with human response times, saying "just one more prompt" at 11pm when you should have stopped working hours ago, or moving creating bottlenecks in the non-coding parts of your process.
Others are harder to spot. Developers in one controlled study were 19% slower with AI while believing they were 20% faster. Pull request descriptions ballooned to 6 times their former length while the humans trying to read them fell further and further behind. All this while our industry has stopped hiring and mentoring the junior developers who are supposed to become the next seniors.
In this talk we'll go through the most serious side effects of AI-assisted development, look at what the research shows, and leave with practical interventions you can start taking today.
The S in MCP is for Security
The Model Context Protocol gives AI models a powerful way to call into your .NET applications through tools and resources. It also creates a new class of security problem: the person using the AI client may end up seeing data or performing actions they would never be allowed to do in your usual UI or APIs.
This session shows how to secure MCP endpoints in .NET with OAuth 2.0 and OpenID Connect so that AI interactions stay within the actual permissions of the current user. We look at how to flow identity and claims into MCP calls, apply scope and role checks, respect tenant boundaries, and prevent over-broad tools that let an agent “wander” into other users' data.
Using practical examples, we walk through securing MCP tools that wrap APIs, databases, and files, and show how to shape them so they only operate on data the user is allowed to access. We also cover auditing and monitoring so you can see what AI-driven traffic is doing in production.
This talk is for developers and architects who want to adopt MCP in .NET without creating a surprise escalation path for their users.
Software Supply Chain Security in the Slopsquatting Era
Your AI coding assistant doesn't just write code for you. It also suggests packages and installs them in your project, often while you're looking at something else. These selections are part of your software supply chain, and are surprisingly easy to hijack.
When researchers tested 16 code-generating models, about 1 in 5 of the packages they recommended didn't exist at all, and 43% of those made-up names came back every single time they asked. Attackers are smart, so they register these names and just wait for somebody's tooling to install them. This style of attack is called slopsquatting.
The past twenty years of supply chain defenses assume a human does the installing, and that they might notice any package that was published last Tuesday with 12 downloads and an empty README. However, your agents don't always notice this. Your scanner tools might not either, because brand-new malware isn't on anybody's list yet.
In this talk we'll walk through how these attacks work, which of your legacy defenses still matter, and the process changes that will best protect you from this new threat.
The Median Stack: Why AI Always Picks the Same Architecture
Ask an AI to build you an app and you'll get a React front end and a Node.js with Express back end. Ask again tomorrow, for a different app in a different industry, and you'll get the same thing. Models will usually suggest the most common answer in their training data, and the internet contains a lot of React and Node.js examples.
If you're not careful, this can cause every problem to be solved with the tools. A decision your team used to argue about at a whiteboard now gets made by token frequency before anyone has a chance to weigh in.
I've spent years helping teams pick technology that fits their needs and constraints, and AI hasn't ended that work. It has just moved it earlier, because a model will happily honor a good architecture decision, but only if somebody makes one.
In this talk we'll make architecture an explicit step again: choosing your stack before code generation starts, writing decisions down where agents actually honor them (CLAUDE.md, ADRs, custom skills/instructions), and using architecture tests to catch drift in your CI process.
Plus or Minus Infinity: Software Estimates After AI
I've been estimating software projects for nearly three decades, so when AI started making some work dramatically faster, I paid close attention, because "some" is hard to estimate.
In controlled studies, developers finished certain tasks 55% faster with AI while other work came out 19% slower, and my own experience has back this up. It turnes out that AI accelerates work that is well-defined and well-guarded, and it punishes ambiguity: vague requirements become confident code that solves the wrong problem, missing tests let rework pile up quietly, and a shaky release pipeline throttles however fast the code arrives.
That means the fundamentals we've preached for twenty years (requirements gathering, automated testing, CI/CD) didn't get less important in the AI era. They became the thing your estimate depends on.
In this talk we'll look at the real numbers on what gets faster and what gets slower with AI, how to adjust your estimates for both, and how to use AI itself to close the fundamentals gaps that make your timelines unpredictable in the first place.
Rewrite Is No Longer a Dirty Word: Modernizing Code with AI
For most of my career, recommending a full rewrite to a client was the fastest way to lose credibility. I've spent years talking clients out of rewrites and into incremental migrations. Lately, though, I've had to adjust my advice.
Teams haven't just avoided rewrites on principle. A rewrite often means digging through 10-20 years of undocumented business rules in the legacy codebase, all while it keeps changing underneath you. This is a perfect storm for timelines and budgets.
AI turns out to be useful against exactly those problems. It can read the code nobody understands anymore and explain what it was trying to do. It writes tests that pin down how the system actually behaves today, before anyone changes a line. And the mechanical parts of a migration turn out to be the kind of grunt work it's happiest doing.
That doesn't make rewrite an automatic yes, but it does mean every modernization decision your team made under the old regime deserves a second look.
In this talk we'll modernize the same legacy application both ways, look honestly at where AI helps and where it doesn't, and build a working decision framework for choosing between rewriting, replatforming, and refactoring in place.
Go Ahead, Reinvent the Wheel: Dependencies in the AI Era
For my whole career, "don't reinvent the wheel" has been one of software's few unquestioned rules. Pulling in a library was free, and writing it yourself cost days you didn't have. So we imported everything, and we accepted what came bundled with that choice: APIs to learn, breaking changes, maintainers who walk away, and a tree of transitive dependencies you never asked for.
In 2016, an 11-line package called left-pad got yanked from npm and broke builds across the internet. We laughed nervously and kept right on installing, because what else were we going to do? Write it ourselves?
Well, now we can. A tested, purpose-built version of that 11-line utility takes minutes to generate and review, so "free" is no longer the library's best feature. Today you're weighing code you own and understand against a permanent relationship with someone else's roadmap.
That still probably doesn't mean writing your own cryptography library (please don't), but the small and medium dependencies on your list deserve a decision now instead of a reflexive install.
In this talk we'll work out which dependencies still earn their place, which ones you should generate and own instead, and how to keep an AI-built utility from becoming its own maintenance problem.
AI Only Moved My Bottlenecks: Accelerating the Rest of the Software Lifecycle
I've seen the same story play out at client after client. The team adopts AI coding tools, developers get dramatically faster, everyone's excited, and three months later the release calendar looks exactly like it did before.
A team ships only as fast as its slowest step, and even before AI, writing the code wasn't always the slowest step. Manufacturers figured this out in the 1980s and named it the Theory of Constraints: speed up any step except the constraint and you get nothing but a bigger pile of work stacked in front of it. Sound familiar? In one survey of 3,500 developers, 68% said AI saves them 10 or more hours a week, and half said they lose just as many hours to reviews, approvals, and other organizational friction.
In this talk we'll use Theory of Constraints to find your team's real bottleneck, tour the five places it usually hides (code review, QA, requirements, deployments, and environments), and apply AI in ways that can help fix it. Then you can go find the next bottleneck, because there's always a next one.
Asking for a Friend: Will Developers Still Have Jobs in 5 Years?
There have always been two kinds of developers. Some of us fell in love with the code itself: the elegant class hierarchy, the clever one-liner, the satisfaction of a perfectly organized solution. Others mostly wanted to solve interesting problems for people, and software just happened to be the best tool available. There's nothing wrong with either kind, and most of us are a mix of both. But AI is only coming for one of those job descriptions.
The answer to the title question, by the way, is yes. The employment data doesn't show developer jobs disappearing. It shows the job changing shape underneath us. Producing syntax is getting cheap, but what stays stubbornly human is the judgment: knowing what to build, how to architect it, which tools and platforms actually fit the constraints, and how the thing should work, so you don't end up replacing a bad process with a faster, automated version of the same bad process. Those calls were always the hard part of this job, but now they're becoming most of it.
I've spent nearly three decades building software and the last ten hiring the people who build it, and what I look for in a developer has changed more in the last two years than in the twenty before.
In this talk we'll look at what the hiring data actually shows, which developer skills are in gaining value and which are becoming commoditized, and how to grow toward the problem-solving end of the spectrum while there's still plenty of runway.
SaaS Isn't Dead, But It Is Optional Now
I run a software consultancy where I've watched small and midsized businesses contort themselves around software that was never built for them: CRMs that don't fit how they sell, CMSes that don't fit how they market, time-tracking tools that flatten the way their teams actually work. As you adopt more of this software, the things that make those businesses distinct get a little harder to do.
For decades, the answer was "deal with it." Custom software was for enterprises with seven-figure budgets. SMBs got off-the-shelf or nothing. But thanks to AI, the math just changed.
This session is the story of how we replaced our SaaS stack at Trailhead, my medium-sized consultancy, including our marketing platform, CMS, CRM, and internal time-tracking tool. Then we layered AI on top of it, building a meeting transcript documenter, an internal assistant trained on our SOPs and meeting history, an tool to catch process drift before it becomes a problem, and a time-entry consistency checker.
The principle we kept coming back to: own what makes you unique. This shift isn't just about saving money. It's about refusing to rent your operational identity from a vendor whose roadmap doesn't care about your business.
There are places where SaaS is still the right answer, and I'll be honest about which ones. But the frontier of what's reasonable for an SMB to own has moved further in the last year than in the previous twenty, and most operators are still working from the old map.
Getting Your Software Backlog to Zero with AI
Every SMB running custom software systems has a list somewhere of things they “should really” do to their software. It’s usually buried in a backlog tool, a spreadsheet, or a half-remembered conversation. Customer self-service tweaks. Internal dashboards that would save hours every week. Cleaning up reporting. Automating the thing someone still does manually every Friday afternoon. None of it is controversial. All of it lost, over and over, to whatever was on fire that week or to the reality that it would take a senior developer a couple of months to get it done.
Thanks to AI, that math is changing.
Over the last year at Trailhead, working with companies our own size, we’ve watched that same pile or work start to move for the first time in years. Work that used to require careful scoping, multiple handoffs, and a meaningful budget now gets done in a couple of weeks or a few focused days when someone knows how to aim AI at it. Not everything, and not always cleanly, but enough that the backlog is no longer theoretical.
This session is a working playbook for clearing that list. I’ll walk through real examples like generating admin tools on top of existing databases, building one-off integrations between systems that never quite justified a project, tightening up customer onboarding flows, and turning tribal knowledge into usable internal tools. You’ll leave with a prioritized checklist of high-value backlog items, realistic time and cost ranges for each, and a simple decision framework for what’s worth doing now versus leaving on the shelf.
If you’ve ever said “we should really get to that someday,” this is how you get to zero.
AI Productivity Paradox: A Report from the Front Lines of AI Adoption
I run a software consultancy where we've gone deep on AI, and most of our team has been heavy on it for over a year. Here's what we've learned: it's powerful, but not all upside.
At the surface is the paradox of feeling faster without actually shipping faster. Go deeper and you find your junior employees never building their underlying skill, because the AI is doing the reps for them. Your senior employees, meanwhile, are worn down from evaluating AI output all day instead of producing their own. Your team starts to trust the AI so much that their own judgment slips. Work with it long enough and a kind of brain rot sets in, along with a new impatience for human-paced work.
This session is about being honest about the tradeoffs you're already making, spotting them before they become structural, and getting ahead of them while it's still possible. It's a talk for leaders who've gone all-in on AI and want to know the road bumps to expect before they hit them.
Copilot, Claude, and Cursor Walk Into a Repo: Comparing AI Coding Tools
AI coding tools are everywhere right now, and most developers are already using at least one of them. What’s less clear is how they actually differ once you move past marketing pages and start using them on real code, with real constraints, and real consequences.
In this talk, I'll put GitHub Copilot, Claude, and Cursor through the same set of realistic scenarios and compare how they behave. Not just greenfield demos, but inside an existing codebase where context, tradeoffs, and prior decisions actually matter.
We’ll look at how each tool handles common development tasks like understanding unfamiliar code, modifying existing behavior, refactoring, and responding to ambiguous requirements. More importantly, we’ll examine where they tend to help, where they quietly get in the way, and how their failure modes differ in ways that matter to working developers.
The goal isn’t to declare a winner. It’s to give you a clearer mental model of what these tools are good at, what they’re not, and how to use them without over-trusting them. You’ll leave with practical guidance on choosing the right tool for the job, setting better expectations for yourself and your team, and staying firmly in control when AI has the keyboard.
Pragmatic AI: 10 AI Features Your Users Actually Want
At many companies right now, the directive is coming from the top: “We need AI in our product.” CTOs hear it from boards. Product leaders hear it from executives. Engineering teams hear it from everyone. Everyone except the end users, that is.
Drawing from real production systems, we’ll look at 10 AI-driven features that actually deliver value by automating work users currently struggle with. These pragmatic patterns will give you ideas where places you can use AI to reduce friction, save time, and get things right more often.
We'll explore how the real question isn’t “where can we add AI?” but “what problems can AI best solve for the users?” You’ll leave with practical examples for where AI might belong in your product, how to explain those decisions to leadership, and how to ship AI features that users actually want.
.NET and PostgreSQL: A Match Made in Heaven
If you’ve spent years building .NET applications on SQL Server, making the jump to PostgreSQL can feel both exciting and unfamiliar. But PostgreSQL has quietly become the most advanced, feature-rich open-source relational database on the planet, and a fantastic partner for modern .NET applications. In this session, we’ll demystify PostgreSQL from a .NET developer’s point of view: the differences, the similarities, and the superpowers you gain once you embrace it.
We’ll explore how PostgreSQL handles data types, indexing, JSON, full-text search, extensions, and performance tuning while comparing each concept to its SQL Server equivalent so nothing feels foreign. You’ll learn how EF Core, Dapper, and raw SQL integrate with Postgres, what to watch out for during migrations, and how to avoid common pitfalls around collation, identity strategies, date/time handling, and more.
Whether you’re modernizing a legacy system, building cloud-native services, or simply looking to reduce licensing costs, this talk will give you the confidence to use PostgreSQL effectively with .NET. You’ll walk away understanding not just how to use Postgres, but why so many .NET teams are choosing it today, and why the two really are a match made in heaven.
Old API, New Tricks: Add MCP to Existing .NET REST Endpoints
Your existing .NET Web APIs have served you well—but what if they could do more with them in the era of AI? In this session, we’ll explore how to breathe new life into your existing ASP.NET Web API endpoints built with ASP.NET CORE by adding Model Creation Protocol (MCP) capabilities to them.
We'll look at how the MCP C# SDK makes it simple to annotate your existing controllers, instantly transforming your REST endpoints into AI-powered services that can empower LLMs and agents. We’ll also compare this approach to a no-code approaches using Azure API Management.
Finally we'll look at where both of these approaches fall short and are only a starting point for a good long-term MCP design. You can use then to jump start the process and then follow the path we outline together to evolve your APIs from technical plumbing to intelligent, task-focused tools that solve real problems using AI—all without starting from scratch.
When Bad Libraries Happen to Good Code
When building applications, choosing the right 3rd party libraries can mean the difference between smooth sailing and a nightmare. With so many options available, how do you make smart choices that keep your codebase maintainable and your team productive?
In this session, we’ll explore four simple rules for choosing libraries: keeping things small, isolated, uncomplicated, and replaceable. You’ll learn how to evaluate libraries for quality, support, and longevity, avoid vendor lock-in, and design your applications to minimize risk if a dependency fails you.
Through real-world examples (both the good and the not-so-good), we’ll cover practical tips for maintaining flexibility, performance, and sanity while working with 3rd party tools.
‘Why Did They Do That?’ and Other Mysteries Solved by ADRs
We've all said it. “Why did they do it like that?” Without Architectural Decision Records (ADRs), these mysteries are inevitable. But don't fear, ADRs don’t mean boring documentation—these lightweight notes capturing the "why" behind your team’s decisions, saving you from future frustration and misunderstandings.
In this session, we’ll explore:
* Why teams forget their own decisions (spoiler: memory isn’t version control).
* How to write ADRs that are concise, useful, and not boring.
* Funny examples of what happens when ADRs are missing—and how they can save your sanity.
Say goodbye to “What were they thinking?” and hello to “Oh, that’s why!”
Cache Me If You Can: Supercharging .NET APIs with Caching
Are your .NET Web APIs crawling at a snail’s pace? Is your database groaning under the load of too many requests? If you’re nodding along, it might be time to turbocharge your APIs with a caching layer to transform your application’s performance.
In this session, we’ll look at APIs built with .NET and what can make them slow. I’ll show you what makes an endpoint a good candidate for caching, and show you how adding it can help alleviate performance problems. We’ll look at Redis and why it’s such a good option for your in-memory cache, and explore the new ASP.NET caching capabilities introduced in .NET 9 which provide enhanced performance and flexibility for your caching strategies. Finally, we’ll discuss some of the common pitfalls of caching implementations and explore the best tooling and libraries to help ease your caching implementation in .NET.
If you want to learn how to supercharge your .NET APIs with effective caching strategies, then make sure to attend this session!
Simplicity in Action: Building Maintainable Web Apps with .NET and HTMX
Single-page applications (SPAs) have revolutionized the user experience, enabling the creation of rich, modern applications. However, they often require a significant amount of front-end code, typically written in TypeScript or JavaScript, which can add complexity and maintenance challenges. This session presents an alternative approach by guiding you through the process of building a web application using HTMX and .NET, reducing the need for extensive front-end coding.
We'll explore HTMX which allows you to access AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML, using attributes, so you can build modern user interfaces with the simplicity and power of hypertext with little-to-no JavaScript. We will also look at how to use these two technologies together seamlessly to build robust, maintainable web applications.
This session is a must-attend for web developers seeking to enhance their skills and learn about the latest trends and best practices in web development. Join us for an engaging and informative learning experience!
The Complete AI Toolkit for .NET (Workshop)
Artificial Intelligence (AI) and Machine Learning (ML) are revolutionizing the software industry, and .NET developers are uniquely positioned to bring these powerful technologies into their projects. This hands-on workshop is designed to guide you through the myriad of tools, libraries, and services available for integrating AI and ML into your .NET applications.
We will explore a range of topics, starting with Open AI and Azure Open AI services, which provide a suite of powerful tools and APIs for using LLM and other generative AI models. We will delve into Azure AI services and Azure ML, which offer cloud-based solutions implementing your own AI and ML.
We will also cover ML.NET, a cross-platform, open-source machine learning framework that allows .NET developers to develop their own models and infuse custom ML into their applications without requiring expertise in ML.
Lastly, we will dive the Semantic Kernel and Cognitive Toolkit. will Semantic Kernel is a tool for orchestrating AI plugins and Cognitive Toolkit is a library that allows developers to create their own neural networks from scratch.
This workshop is a must-attend for .NET developers seeking to enhance their skills and learn about the latest trends and best practices in AI and ML. The workshop will be hands-on, providing attendees with practical experience in leveraging AI and ML tools in .NET. Join us for an engaging, informative, and hands-on learning experience!
Rebuild your APIs Better, Stronger, Faster with Minimal APIs
If you currently have a controller-based API built in ASP.NET or ASP.NET Core, you might be eager to embark on the journey of transitioning it to a Minimal API approach, but not know the best process to make it happen. If so, this talk is tailor-made for you.
We will delve into the advantages of using Minimal APIs, including the simplification of complexity and the boost in performance. We'll also go though a methodical, step-by-step migration process, complete with illuminating code examples so you can see the process in action.
By the end of this session, you'll be well-equipped to update any of your ASP.NET or ASP.NET Core APIs from controller-based code into the realm of sleek and effective Minimal APIs.
Old to Gold: How to Modernize Your Legacy ASP.NET Apps Gradually
Legacy applications built with ASP.NET can take a long time to migrate. Doing this work all at once isn't very agile, so in this session we'll explore using YARP (Yet Another Reverse Proxy), .NET Upgrade Assistant, and the "Strangler Fig" pattern to incrementally migrate your legacy ASP.NET applications to modern technologies like ASP.NET Core.
While it might have a funny name, YARP is a very serious tool when it comes to helping you upgrade your legacy ASP.NET projects to ASP.NET Core. The best part is, it helps you do the upgrade gradually and with minimal impact to your users. When done with the help of the .NET Upgrade Assistant, you can also kick off the process without breaking a sweat.
You'll walk away more knowledgeable about these tools that help you with your migrations, and learn some of the shims that are available the make certain cross-cutting concerns easier to integrate between your legacy and modern applications. If you might have a legacy migration in your future, you're going to want to join us for this!
Building a Well-Architected API in .NET (Workshop)
For many applications, a modular monolith architecture is an ideal fit, providing the benefits of code modularity and simplicity of deployment without the unnecessary complexity of microservices. This workshop is designed to guide you through the process of building a .NET API project as just such a well-architected modular monolith.
We will start by exploring Minimal APIs, a lean and efficient way to build APIs in .NET. The workshop will also cover the Command Query Responsibility Segregation (CQRS) pattern, as a way to effectively separate read and write operations for improved performance and scalability. We will then delve into FluentValidation, a library for building complex validation rules that are easy to read and maintain.
The concept of Vertical Slice Architecture will be introduced, an architecture style that structures projects around features rather than layers, increasing cohesion and reducing coupling. The workshop will cover the use of MediatR for implementing the Mediator pattern, promoting loose coupling and better separation of concerns. We will also get hands-on experience with Micro ORMs, which simplify data access while maintaining flexibility. Lastly, we will dive into Carter, a library that allows writing more functional code in ASP.NET Core.
This workshop is a must-attend for .NET developers seeking to enhance their API development skills and learn about the latest trends and best practices in the industry. The workshop will be hands-on, providing attendees with practical experience in building a well-architected API in .NET. Join us for an engaging, informative, and hands-on learning experience!
Easy Distributed Apps with .NET Aspire
This workshop is designed for .NET developers eager to leverage the power of .NET Aspire, a powerful framework for creating configurable, cloud-native applications, for building distributed applications in C# and .NET.
You'll learn how to set up and structure projects, streamline connections and configurations, and configure service discoverability for seamless integration. We will explore .NET Aspire's curated NuGet packages for integrating with services like PostgreSQL, Azure Cosmos DB, and Redis, and guide you through project management and deployment using the Aspire Dashboard and Azure Developer CLI.
Hands-on labs and demos will reinforce your learning, and we'll share best practices for maximizing .NET Aspire's potential in your projects. By the end of this workshop, you'll be equipped to build robust, scalable distributed applications with .NET Aspire. Whether you're new to .NET Aspire or looking to deepen your expertise, this workshop will enhance your development skills and keep you ahead in the technology landscape.
Join us and transform your approach to distributed application development with .NET Aspire.
Avoidifying Over-Complexification: Rooting Out Over-Engineering in Your Projects
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.
Nuget Packages Every .NET Dev Should Know About
There’s nothing worse than finding out about a great library after it’s too late to use it for your project. Don’t miss out; join us as we look at an overview of some of my favorite Nuget packages, all of which can quickly and elegantly help you solve common problems that we .NET developers face.
Data access, validation, list manipulation, design patterns, testing, fault tolerance—we’ll cover a little bit of everything, and you’ll walk away knowing a list of tools you may have not heard of before, and knowing how and when to use them in your projects.
Multi-Tenant Architecture for .NET Web APIs
Some applications aren’t a good fit for NoSQL. If you’re doing a large-scale .NET project that is a better fit for relational databases like SQL Server, how do you set it up to scale well?
In the session, I’ll recount some of the useful lessons I’ve learned building highly scalable .NET APIs that are built using traditional relational databases. We’ll discuss multi-tenancy, shared databases, shared data, microservices, and CQRS, among other useful design patterns, architectures, and tools.
Improving Your Validation Game with Fluent Validation for .NET
Just about every application needs some sort of validation in it. If you’re a .NET Developer, you’ve no-doubt mostly been doing validation using the data annotation attributes from the System.ComponentModel namespace. These attributes are built-in to .NET by default, and can work well in some situations, but there’s also another option that can be better in several important ways
In the session, we’ll exploring the advantages of using Fluent Validation in your C# and .NET applications. This method of validation creates cleaner code that better follows the single-responsibility principle, gives you more control over custom validation, can be fired conditionally, makes unit testing easier, and even includes client-side support for web apps. If your .NET validation game has gotten a little stale, come see how to step it up with fluent validation.
Don’t Build a Distributed Monolith: How to Avoid Doing Microservices Completely Wrong
As a consultant, I get to see many systems built by many different developers. Recently, I’ve seen an uptick in the number of systems built with a microservice architecture in mind, but those systems often include a lot of the same mistakes that keep them from working well.
In this session you’ll learn from my experiences and get pointers on what to avoid in your microservices implementations so that you don’t accidentally build something which has all the worst aspects of a monolithic application and the worst aspects of microservices These monsters are what I call “distributed monoliths”, and I can help you avoid building one accidentally.
Cloud-Native Architecture for .NET Developers
If you're a .NET Developer, you're probably used to building applications with technologies like ASP.NET, Entity Framework, SQL Server, IIS, and other related ones. But, the cloud is quickly changing the way application are built, and allowing us to write software that is much more performant and scalable than ever before. Will those skills translate to this new world?
Come learn how to apply your existing C#, .NET, and relational database knowledge to the world of cloud-native application development. We'll look at an overview of the technologies that are likely to change the way we develop applications in the future--things like static sites generation, the JAMStack, serverless applications with Azure Functions, and cloud-scale databases with SQL Azure and CosmosDB.
If you're a .NET Developer, you don't have to be afraid of the cloud's impact on your future. I'll show you how you're already set up for success in the cloud.
Choose Your Own Adventure: Lessons Learned from an Unusual Journey
A pro-adventure mindset can lead to exciting opportunities in both your personal and professional life. Join me as I share my unusual story of taking a leap of faith and embarking on a year-long RV adventure across the USA.
During my journey, I learned how having a pro-adventure mindset is essential for unlocking new opportunities and taking risks that can lead to both personal and professional growth. I'll show you how my own outside-the-box thinking led to my incredible experience of traveling to all 48 states while living in an RV and working remotely, plus how it changed my personal and professional trajectory.
By hearing my story, I hope you'll be inspired to see your own career and life path in a different light, and be encouraged to step out of your comfort zone to discover your own adventure. Don't miss this chance to learn about how embracing a pro-adventure mindset can help you achieve your wildest dreams!
A Data Access Layer You're Proud of without Entity Framework
If you're a .NET developer, it almost goes without saying that you use Entity Framework as part of the data access code on your software projects. Sometimes, EF is just right for the job, but other times you want something more simple, with better control of the generated SQL queries, and more performant. Over the years, several micro-ORMs (object relationship mappers) have evolved for just this purpose. Sometimes the simplest solution is the best one.
I'd like to walk you through a few of the more popular .NET micro-ORM options so you can see how you can make a simple, high-performance, and easy to use data access layer that you can be proud of.
Warm and Fuzzy: Semantic Search in .NET
Searching isn't just about exact matches anymore—users expect search results that understand context and adapt to their input. Enter the world of AI-driven fuzzy search! In this session, we’ll explore how to implement powerful search capabilities in .NET using Microsoft.Extensions.AI, Ollama, ChatGPT, and vectorization techniques.
You’ll learn:
* How to integrate AI into your .NET applications with Microsoft.Extensions.AI.
* How ChatGPT and Ollama enhance contextual understanding.
* Why vectorization is key to semantic search and how to implement it.
Through live demos and practical examples, you'll leave equipped to build better, more user-friendly search experiences. Whether you're a .NET developer or an AI enthusiast, this session will give you tools to level up your search game.
Oops, I Leaked It Again: API Security Mistakes Fixed
APIs are the backbone of modern applications—but one small mistake can expose sensitive data, allow unauthorized access, or even take down your entire system.
In this session, we’ll explore the most common API security blunders (yes, including some real-world horror stories) and how to fix them with practical, developer-friendly rules of thumb. From accidental data leaks to broken authentication, we’ll cover the pitfalls that put your APIs at risk and the best practices that will save you from disaster. Whether you’re building a new API or securing an existing one, this talk will help you go from “Oops” to “Locked Down”—with a few laughs along the way.
Mission-Critical Code: What NASA’s Power of Ten Can Teach Us
Ever wonder how NASA writes software that literally can’t afford to fail? Meanwhile, back on Earth, our code is held together with duct tape and //TODO comments. The stakes might be a little lower for most of us—nobody's oxygen supply depends on our latest API deployment (hopefully)—but reliability, maintainability, and simplicity still matter.
Enter NASA’s Power of Ten rules: a set of software engineering principles designed to minimize complexity and maximize reliability. In this talk, we’ll explore these ten commandments of mission-critical coding, from banning recursion (gasp!) to keeping functions tiny and predictable. Along the way, we’ll discuss how these rules apply beyond space exploration—to web apps, enterprise systems, and anywhere else software keeps the lights on.
Whether you're launching rockets or just trying to keep production from crashing at 2 AM, these lessons can help you write code that’s more robust, maintainable, and maybe even astronaut-approved. So strap in, and join us for a journey through the Power of Ten—no space suit required!
Months to Days: AI-Assisted Modernization of Legacy .NET Apps
You’ve got critical .NET applications still running on .NET Framework or early .NET Core—and a backlog that never leaves room for modernization. In this session, we’ll explore how the GitHub Copilot app modernization agent can help you upgrade those apps to modern .NET and prepare them for Azure, in days instead of months.
We’ll start with a realistic legacy .NET solution and ask Copilot to analyze it, generate a modernization plan, and create a working branch. Along the way, you’ll see how the agent updates project files, fixes common API changes, iterates through build and test failures, and surfaces a clear summary of what changed.
But this is not an AI magic show. We’ll also look at where the agent struggles, where architectural judgment still matters, and how to wrap the tooling in a safe, test-driven process. You’ll leave with a practical playbook for combining proven modernization strategies with GitHub Copilot’s new agents to accelerate your journey from legacy .NET to modern, cloud-ready applications.
Pragmatic AI in .NET: Bringing Intelligent Features to Existing Apps
Many teams and stakeholders want to add AI features to their applications, but quickly discover that real, reliable functionality takes more than a simple call to an LLM. This session focuses on practical, production-ready ways to bring intelligent capabilities to existing .NET applications without hype or unnecessary complexity.
We will cover proven patterns such as retrieval-augmented generation, structured prompting, vector search, agent-style workflows, and hybrid approaches that combine LLMs with traditional .NET code. The examples include features that organizations are shipping today: natural language search, document summarization, conversational help, analytics insights, automated workflows, and smarter administrative tools.
Along the way, we will address the architectural and operational considerations that matter in real systems, including data readiness, security boundaries, performance, observability, and cost management. The goal is to give you a clear and practical roadmap for building AI features that users can trust and that your existing .NET architecture can support.
The AI-Powered .NET Developer Workflow
AI is becoming a practical part of how modern .NET teams design, build, test, and maintain software. This session shows what an AI-powered workflow looks like today and how you can bring it into your day-to-day development process.
We will look at how GitHub Copilot, Copilot Agents, and other AI-assisted tooling fits into routine development work, including code analysis, test generation, refactoring, build and debugging assistance, and understanding unfamiliar or legacy codebases. We will also highlight patterns that pair well with these tools, such as semantic code search and the emerging AI libraries available in the .NET ecosystem.
You will see practical examples of developers working with AI as part of their normal workflow, along with clear guidance on when human judgment is still required. The session closes with recommendations for guardrails, team processes, and adoption strategies that keep code quality high while allowing AI to accelerate development.
Identity-Aware MCP Endpoints in .NET
The Model Context Protocol gives AI models a powerful way to call into your .NET applications through tools and resources. It also creates a new class of security problem: the person using the AI client may end up seeing data or performing actions they would never be allowed to do in your usual UI or APIs.
This session shows how to secure MCP endpoints in .NET with OAuth 2.0 and OpenID Connect so that AI interactions stay within the actual permissions of the current user. We look at how to flow identity and claims into MCP calls, apply scope and role checks, respect tenant boundaries, and prevent over-broad tools that let an agent “wander” into other users' data.
Using practical examples, we walk through securing MCP tools that wrap APIs, databases, and files, and show how to shape them so they only operate on data the user is allowed to access. We also cover auditing and monitoring so you can see what AI-driven traffic is doing in production.
This talk is for developers and architects who want to adopt MCP in .NET without creating a surprise escalation path for their users.
Michigan Technology Conference 2026 Sessionize Event Upcoming
TechBash 2026 Sessionize Event Upcoming
The Cloud & AI Summit 2026 Sessionize Event Upcoming
WeAreDevelopers World Congress 2026 - North America Sessionize Event Upcoming
NDC Oslo 2026 Sessionize Event Upcoming
KCDC 2026 Sessionize Event Upcoming
Nebraska.Code() 2026 Sessionize Event
Update Conference Krakow 2026 Sessionize Event
NDC Sydney 2026 Sessionize Event
NDC London 2026 Sessionize Event
CodeMash 2026 Sessionize Event
Microsoft Zero To Hero Community - 2025 User group Sessionize Event
.NET Conf 2025 Sessionize Event
TechBash 2025 Sessionize Event
Momentum 2025 Sessionize Event
KCDC 2025 Sessionize Event
Nebraska.Code() 2025 Sessionize Event
Update Conference Krakow 2025 Sessionize Event
NDC Melbourne 2025 Sessionize Event
NDC London 2025 Sessionize Event
CodeMash 2025 Sessionize Event
Momentum 2024 Sessionize Event
MIDOTNET User group Sessionize Event
dev up 2024 Sessionize Event
KCDC 2024 Sessionize Event
Stir Trek 2024 Sessionize Event
Michigan Technology Conference 2024 Sessionize Event
NDC Sydney 2024 Sessionize Event
CodeMash 2024 Sessionize Event
TechBash 2023 Sessionize Event
NDC Porto 2023 Sessionize Event
KCDC 2023 Sessionize Event
NDC London 2023 Sessionize Event
TechBash 2022 Sessionize Event
.NET Conf 2022 Sessionize Event
Momentum 2022 Sessionize Event
Code PaLOUsa 2022 Sessionize Event
KCDC 2022 Sessionize Event
Developer Week '22 Sessionize Event
Stir Trek 2022 Sessionize Event
TechBash 2021 Sessionize Event
KCDC 2021 Sessionize Event
Code PaLOUsa 2021 Sessionize Event
Visual Studio Live! Las Vegas & Austin 2020 Sessionize Event
CodeMash 2020 Sessionize Event
TechBash 2019 Sessionize Event
Music City Tech 2019 Sessionize Event
Code PaLOUsa 2019 Sessionize Event
KCDC 2019 Sessionize Event
Stir Trek 2019 Sessionize Event
Music City Tech 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