Become an Expert with Async/Await in C#

A hands-on asynchronous and parallel programming workshop for C# teams. A world-class workshop that has been presented at conferences such as NDC Oslo, now available for your team, on site or remote.

Who it's for

C# developers who use async and await every day but have never seen what the compiler does with them. If your team has shipped a deadlock, a missing exception, or a "why is this slow?" bug that traced back to async code, this workshop is for them.

What your team leaves with

• The ability to read compiler-generated async code and predict how a method will behave before running it.
• A checklist of the async/await mistakes that cause deadlocks, thread pool starvation, lost exceptions, and unresponsive UIs, and the fix for each one.
• A working mental model of SynchronizationContext, ExecutionContext, ThreadStatic, and Principal, and why ConfigureAwait matters.
• The confidence that comes from building a Task from scratch and using it with the built-in keywords.
• Clear rules for when to reach for Task.WhenAll, Task.WhenAny, Task.WhenEach, Parallel, PLINQ, the concurrent collections, and System.Threading.Channels.

How it works

Short lectures, timed coding challenges, and group review. Each module follows the same rhythm: I introduce the topic and connect it to the code you are about to change, you attempt a timed challenge (20 to 45 minutes), we review the approaches in the room, and then we walk through the solution together.

Every challenge app has a workshop guide built in. It checks your code against each step when the app starts, unlocks the next step when the previous one passes, and explains what happened next to what was expected, with a hint for anything that does not match. Nobody gets stuck, and nobody gets lost.

Curriculum

Day 1: Asynchronous programming

1. Thread switching and compiler-generated code. What async and await turn your method into, and why that matters for every line after them.
2. Correcting common async/await mistakes. Fix a Blazor app with a code review's worth of async bugs: fire-and-forget from lifecycle methods, blocking waits, dropped cancellation tokens, and captured contexts that were never needed.
3. .NET internals. SynchronizationContext, ExecutionContext, ThreadStatic, Principal, and how they flow (or fail to flow) across an await.
4. Build your own Task. Implement Task from scratch and use it with the built-in async and await keywords.

Day 2: Parallel programming

5. Asynchronous vs parallel. Waiting is not working. When each one helps, and how to spot the difference in a profiler.
6. Coordinating multiple tasks. Task.WhenAll, Task.WhenAny, and Task.WhenEach, plus the race conditions and deadlocks that hide between them.
7. Data parallelism. Put every core to work with the Parallel class and PLINQ, and know when not to.
8. Concurrent collections. Keep shared state correct under load.
9. Channels. Connect producers to consumers with System.Threading.Channels.

The challenge apps are Blazor apps, so attendees run everything in a browser with only the .NET SDK required to be installed. Every module has a starter project and a finished project, and the whole workshop repo is open source: TheCodeTraveler/BecomeAnExpertWithAsyncAwait.

What attendees said

"Brandon is a great speaker and very understanding person who has a ton of very useful information. I enjoyed the content very much and I can see a lot of places where I can implement async and await in both my own personal projects but also at work."

"I loved seeing my implementations turn all the red components green in the website. Well done Brandon!"

"The hands-on exercises were well made."

Where it has run

• NDC Oslo 2026, two days
• NDC London 2026, one day

Formats and pricing

Flat rate per team, on site, travel billed at cost.

• 2 days is the full curriculum above, as run at NDC Oslo.
• 3 days is the full curriculum plus a third day where the team applies it to your own codebase, with me in the room.
• 5 days turns every module into a cycle: learn the topic in the morning, then find the place in your codebase where it applies and implement it that afternoon. The team leaves with the material and with the changes already merged.
• Remote delivery is 25% less and runs in half-day blocks, which fits distributed teams and lets people apply each module the same afternoon.
• 1-day remote pilot for up to 20 developers: $9,500. Day 1's four modules in one day. Good for a first engagement or a single team.
• More than 30 developers? Run a second cohort rather than a bigger room.

Every attendee keeps the slides and the workshop repo. Optional add-ons, priced per engagement: a review of your team's async code before the workshop so the examples come from your own project, follow-up Q&A sessions at one and three months, and recording rights.

Logistics

• Attendees need a laptop with the .NET 10 SDK and an editor. Module 0 in the repo covers setup, and day 1 starts with time to fix whatever did not install.
• On site: one room, a projector, and Wi-Fi. Remote: your video platform or mine.
• Want your team to warm up first? My Dometrain courses Asynchronous Programming in C# and Parallel Programming in C# cover the same ground at a gentler pace.

Tell me about your team and the dates you have in mind: thecodetraveler@gmail.com.