Tim Purdum
Creative GIS and Web-based .NET Engineer
Cedar Falls, Iowa, United States
Actions
Tim Purdum is the visionary behind the GeoBlazor mapping library and serves as the Director of Product Development at Dymaptic. With a robust background in .NET and web technologies, Tim has been focused on Geographic Information Systems (GIS) since 2021. His expertise and passion for technology have made him a sought-after speaker at numerous conferences, including Visual Studio Live, TechBash, Iowa Code Camp, and DevUp. Tim lives in Cedar Falls, Iowa.
Area of Expertise
Topics
Spatial Data in .NET: From Database to Dashboard
Most .NET developers have worked with dates, strings, and decimal columns their entire careers — but the moment someone asks "show me all the customers within 30 miles," the usual LINQ query falls short. Spatial data isn't exotic; it's just a data type most of us were never taught to use. And once you know how, it unlocks queries, analyses, and visualizations that are impossible any other way.
This session walks the full path from database to dashboard. We'll start in the schema — defining geometry and geography columns in SQL Server and PostgreSQL, mapping them through EF Core with NetTopologySuite, and writing spatial queries (intersections, distance calculations, containment checks) that run on the database, not in memory. From there, we'll serialize results as GeoJSON, feed them into a Blazor front end, and render them as interactive map layers users can explore. Along the way, you'll see how spatial indexes actually work, when to choose `geography` vs. `geometry`, and how to avoid the performance traps that catch most first-timers.
No GIS background needed — just a willingness to think of your data as shapes on a map instead of rows in a grid.
Software Engineering in the Age of AI
AI coding agents don't just change how we write code — they change what it means to be a software engineer. The developers getting the most out of these tools aren't the ones with the cleverest prompts, but the ones who've invested in the infrastructure that makes AI effective: thorough documentation, comprehensive test suites, automated code reviews, and disciplined task management. The best AI engineers are the ones who were already doing good engineering.
But there's a human side to this shift. When your collaborator never sleeps and never needs a break, how do you set boundaries? Is it OK for your agents to stop running while you live your life? How do you avoid "just one more iteration" at midnight?
In this session, we'll explore both sides of AI-assisted development — the practical: building the scaffolding that turns an AI agent from an unpredictable autocomplete into a reliable teammate, and the personal: managing your time, energy, and expectations alongside a tool that's always ready to go, even when you're not. You'll leave with a concrete playbook for making these tools work for you without letting them run you into the ground.
Real-Time Data Visualization in Blazor
Dashboards full of stale numbers don't tell the whole story. When your data has a heartbeat — sensor readings, vehicle positions, weather alerts, transaction volumes — your UI needs to keep up. Blazor gives .NET developers a component model that's naturally suited to streaming updates, but bridging the gap from a SignalR hub or an IoT message broker to a responsive, visually rich front end takes more than just calling `StateHasChanged`.
In this session, we'll build a real-time data pipeline from back to front: ingesting live feeds, pushing updates through SignalR, and rendering them as interactive map layers and charts in Blazor — without drowning the browser in redraws. You'll see how to throttle high-frequency streams, batch UI updates for smooth rendering, and layer live data on top of maps and spatial context so users can see not just *what* is happening, but *where*. We'll work through practical scenarios like fleet tracking, environmental monitoring, and live sales activity — the kind of problems where a table of numbers fails and a real-time visualization clicks.
Put Your Business on the Map: Location Intelligence for .NET Apps
Your users, your assets, and your competitors all exist somewhere — and that "somewhere" matters. Location data is one of the most underused tools in a developer's arsenal, yet it can answer questions that no amount of SQL or business logic alone can: Which warehouse should fulfill this order given weather and traffic? Is this address inside our service area? Where are we losing customers, and where should we expand next?
This session shows .NET developers how to integrate spatial analytics into the apps they already build. Through live demos in ASP.NET Core and Blazor, we'll tackle real-world scenarios — route optimization, geofencing, heat maps, proximity analysis, and risk modeling — using ArcGIS services, GeoJSON, and spatial-enabled databases. You'll leave with patterns you can apply on Monday morning. No GIS expertise required.
Not So Minimal APIs & Dependency Extension: Maintaining a Clean Entry Point to your Code
Program.cs is the opening chapter of your application’s story—but it often becomes a cluttered and unwieldy file as projects grow. Minimal APIs offer a clean and lightweight way to structure ASP.NET Core Web APIs without the boilerplate of traditional Controllers, but placing all endpoints directly in Program.cs can quickly lead to chaos. Likewise, as the number of services in your application increases, your dependency injection configuration can overwhelm your startup code.
In this session, we’ll walk through practical techniques for organizing your Minimal APIs and service registrations using static classes and extension methods. You’ll learn how to refactor your startup pipeline into clean, maintainable, and discoverable components—without sacrificing the simplicity that Minimal APIs provide or losing any of your injected services. We’ll also examine how Minimal APIs compare to traditional Controllers to help you choose the right approach for your application.
Location, Location, Location! How Geographic Data Intersects with Your Business
Every business decision is shaped by location—whether it’s monitoring the soil health of farm fields, optimizing deliveries, or uncovering new sales markets. This session shows .NET developers how to unlock the power of geographic data in their applications, using real-world GIS tools and techniques to solve business problems across industries. Attendees will see how to integrate spatial analytics—like route optimization, geofencing, heat maps, proximity analysis, and risk modeling—directly into ASP.NET Core, Blazor, and modern web apps, leveraging ArcGIS services, and integrating their own custom data sources with satellite imagery and public data sets. Through practical demos and architecture guidance, developers will learn how to turn location data into actionable insights that drive business impact—no GIS expertise required.
From Plain English to Interactive Blazor App in 30 Minutes or Less
AI coding assistants aren't just a novelty — they're changing how fast a skilled developer can ship. In this session, you'll watch a fully interactive GIS web application get built from scratch, live on stage, at a pace that would have taken hours just a year ago.
The workflow is simple: describe it, build it, refine it. Using Claude Code alongside GeoBlazor and the ArcGIS Maps SDK, we'll scaffold a Blazor application with an embedded ArcGIS WebMap, wire up interactive widgets, and go all the way to a live spatial data query — powered by complex spatial data query expressions Claude generates on demand. When the output needs adjustment, we refine it conversationally and keep moving. One seamless flow from blank project to working GIS app.
If you've been curious about geospatial development but haven't had time to climb the ArcGIS learning curve, this session shows you how AI flattens it. And if you're already building location-aware apps, you'll leave with a faster, more fluid development loop you can put to work immediately.
Don't Feed the Machine Spaghetti: Code Quality Principles for the AI Era
AI coding assistants have changed the speed at which we write code, but they haven't changed what makes code good! In fact, they've raised the stakes. Repeated logic, unclear naming, and tangled dependencies don't just confuse new developers — they bloat the model context, confuse the LLM, and burn through your token budget while degrading the quality of every suggestion the AI makes. The result? Inconsistent, low-quality output that amplifies your existing technical debt.
In this session, we'll explore why the fundamentals of software architecture — DRY principles, separation of concerns, meaningful abstractions, and testable design — aren't just good hygiene, they are essential for developing quality, sustainable software with AI. We'll look at how to scaffold AI instructions (prompt markdown files, agents, skills) so your tool follows your patterns instead of inventing its own. And we'll do live, side-by-side comparisons: the same coding task with and without architectural scaffolding, so you can see the difference for yourself.
You'll leave with a portable set of LLM instruction templates you can drop into your .NET coding project today.
Practical Copilot: Incorporating AI Into Ongoing Project Development
AI agents and LLMs are revolutionizing software development—but most demos stop at isolated features or greenfield projects. What about the real world, where legacy code and team workflows rule?
In this hands-on session, you’ll learn how to seamlessly integrate AI agents and editors into your ongoing projects. Discover how to delegate tasks to multiple agents as you would with team members, identify the right moments for human intervention, and keep the most engaging work for yourself.
Designed for developers, team leads, and project managers, this session features live demos and actionable strategies you can implement right away.
Building Location-Enabled .NET Web Apps with GeoBlazor
Ready to get your hands dirty building interactive, location-aware .NET web apps? This 2-day workshop will walk you through everything you need to know to integrate advanced mapping features into your Blazor Server or WebAssembly applications using GeoBlazor. From displaying maps to interacting with spatial data and integrating real-time GIS services, we’ll cover it all, with plenty of hands-on labs along the way. Whether you're brand new to geospatial tools or looking to modernize your existing ASP.NET app, you'll leave this workshop with real working code and the skills to bring powerful mapping to your applications.
Understanding Blazor Render Modes
Asp.NET Core Blazor features one of the most powerful and flexible approaches to web development available today, with reusable components that can run client-side or server-side, static or interactive. But great flexibility requires understanding where your code is running, and what features are available in each mode. This session will cover all the render modes of Blazor, client vs. server components, static vs. interactive, and how to nest components with different modes. Examples, successful patterns, and potential pitfalls all will be shared.
Full-Stack Web Development with Asp.NET Core Blazor
Developers who love strongly typed languages like C# but also see the value of rich interactive web applications can now "have it all" with Asp.NET Core Blazor! Blazor is a component-based, reactive framework that builds on top of modern .NET, Razor syntax, HTML, and CSS, to create a single-language full-stack application. Components can be statically generated on the server, be live-updated from the server via WebSockets, or run in the client browser just like a JavaScript SPA application.
In this session, we will learn how to get started with Blazor, as well as some advanced tips and tricks.
State Management in Blazor
Blazor is a powerful .NET UI framework offering developers the power to create rich, interactive web applications. However, one challenge that faces many new Blazor developers is the lack of a clear pattern for managing the state of their data. In this session, we will dive deep into the Razor Component lifecycle and explore essential state management patterns that keep your data clean, your business logic encapsulated, and your UI consistent. Learn to prevent unwanted render cycles and avoid potential performance pitfalls, lost data, or exceptions.
Building Nuget Packages to Make Your Code More Reusable
Whether it's encryption, authentication, state management, or just string utilities, every team has a collection of useful tools that can be reused across projects. Many end up copy/pasting or using a giant monorepo to share this code. By learning to generate Nuget packages and hosting a private Nuget source, your team can quickly add the shared code to any new project, and you can improve these packages iteratively. Learn to pack, publish, and share libraries with Nuget.
Blazor for JavaScript Developers
Are you a front-end developer who works with a .NET back-end, or is just curious about writing a front-end web UI with .NET? This session will cover the Blazor basics, including client and server rendering, and compares it to popular JavaScript frameworks like React, Angular, and Vue. Identify the advantages, disadvantages, top features, and pitfalls when using statically-typed C# and the .NET ecosystem to create full-stack, unified web applications with Blazor, one of the most powerful and performant frameworks on the planet.
Geographically Visualizing Customer Data with Blazor and ArcGIS
.NET developers can quickly create line-of-business web applications with Asp.NET Core Blazor. Learn how to take customer forms and data and bring it alive with interactive maps using ArcGIS and the open-source GeoBlazor library. Visualize and compare your location-based data with ArcGIS Living Atlas layers that highlight socioeconomics, weather patterns, and more.
Cross Platform Development with Blazor
.NET Blazor finally fulfills the promise of write once, run everywhere. This session will show how to set up an application to run on a web server, on the web client, on mobile devices, and desktop, all from a single UI and code base.
Wrapping JavaScript APIs for Use in Asp.NET Blazor
If you are a .NET developer looking to expand your web skills, Blazor is the way of the future, allowing you to write web applications in C# instead of JavaScript. In this session, we will explore how to wrap existing JavaScript APIs and libraries so your dev team can call them directly from C#, abstracting away the JavaScript! You will leave with links to numerous examples of Blazor API wrappers, a blank wrapper template, and a step-by-step guide for writing your own wrapper.
Interactive Map Applications with Blazor and ArcGIS
Mapping and Geospatial Information are powerful tools to analyze and explore customer data. Learn to inject interactive maps with the powerful ArcGIS Platform directly into your Blazor web and MAUI hybrid applications, no JavaScript required!
TechBash 2025 Sessionize Event
Blazor Day 2025 Sessionize Event
dev up 2025 Sessionize Event
Iowa Code Camp Fall 2024 Sessionize Event
TechBash 2024 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