Training Classes

Training Classes

Private Training Workshops

I offer private training for corporate customers. Contact me for more information and to schedule training for your team. Read some testimonials from some of my customers and students.

Training Classes and Modules

Anything I write about or have delivered Pluralsight courses on (see below) is fair game as a topic for a private workshop. Here's a list of my more popular courses and modules. These can be delivered in person or remotely.

  • Clean Architecture with ASP.NET Core
  • Domain-Driven Design with ASP.NET Core
  • SOLID (and other) Principles
  • Event Storming
  • Design Pattern Mastery
  • Improving the Design of Existing Code
  • Testing Tips and Best Practices
  • Web API Best Practices
  • Web Security and OWASP Top 10 Threats
  • Cloud Design Patterns
  • Refactoring Techniques and Code Smells

These are topics that I've delivered to hundreds of developers and which I can say with confidence have dramatically improved the effectiveness of individuals and teams.

Online Courses

Become a better software developer by taking these courses online at your own pace.


My most recent courses have been published with DomeTrain:

Zero to Hero: Modular Monoliths

This bundle has a permanent 20% discount and includes both of these courses for over 10 hours of valuable content:


I’ve published several training courses with Pluralsight since 2010.

Refactoring to SOLID C# Code

This course builds on my previous Pluralsight courses on refactoring and SOLID (see below) and dives into the details of how to refactor some complex real world legacy code. It demonstrates many techniques and design patterns as well as some heuristics for analyzing the quality of code, making plans for how to tackle a long term refactoring, and measuring progress. Watch now

ASP.NET Core 6+ Web API: Best Practices

Modern apps require web APIs more than ever before. This course will teach you best practices for writing better web APIs using ASP.NET Core.

Working with C# Generics: Best Practices

This course will teach you how to apply C# generics in your applications, including best practices and potential pitfalls.

Domain-Driven Design Fundamentals

Fully updated for .NET 5. This course will teach you the fundamentals of Domain- Driven Design (DDD) through a demonstration of customer interactions and a complex demo application, along with advice from renowned DDD experts. Taught with co-instructor Julie Lerman.

Kanban: Getting Started

This course will teach you to apply the principles of kanban to your professional and personal life to reduce stress and waste and increase flow.

C# Design Patterns: Rules Engine Pattern

This course will teach you to apply simple rules engines to problems involving excess conditional complexity. Rules engines are actually pretty simple to build and can help achieve the Open/Closed Principles from the SOLID Principles.

C# Design Patterns: Memento

This course will teach you how to apply the Memento Design Pattern in your C# applications to provide undo/redo functionality.

C# Design Patterns: Template Method

This course will teach you to apply the Template Method pattern to improve the design of your applications by reducing repetition and enforcing workflow requirements in your code.

Design Patterns Overview

Design patterns help developers solve problems using proven approaches. They help teams discuss code using higher level concepts and terms. This course introduces you to design patterns and prepares you to start mastering patterns!

C# Design Patterns: Singleton

This course will teach you when and how to apply the Singleton design pattern (and other ways to achieve the same behavior) to ensure certain classes only have a single instance within your application.

C# Design Patterns: Proxy

Design patterns help you solve common software problems with known, proven approaches. The proxy design pattern is one of the most common and useful patterns you'll encounter. This course shows you when and how to apply the proxy pattern in C#.

Microsoft Azure Developer: Refactoring Code

Building Azure applications that last requires an understanding of software quality and maintainability. In this course, you'll learn how to recognize technical debt in your apps and how to refactor your code without starting from scratch.

This course pulls from the older (but still relevant since this stuff doesn’t change) Refactoring Fundamentals course and is designed to fit within an Azure learning path that Microsoft has partnered with Pluralsight to produce.

C# Design Patterns: Adapter

Design patterns help you solve common software problems with known, proven approaches. The adapter design pattern is one of the most common and useful patterns you'll encounter. This course shows you when and how to apply the adapter pattern in C#.

Refactoring for C# Developers

Over time, software design tends to degrade, and systems become increasingly difficult to maintain. In this course, you’ll learn how to recognize and evaluate potential flaws in your system’s design, known as “code smells.” You’ll be introduced to code smells at the statement, method, and class levels in C# applications. You’ll also learn about the process of refactoring your code to eliminate design flaws and improve its maintainability. Finally, you’ll learn how to apply dozens of specific refactorings to common, known problems in C# applications. When you’re finished with this course, you’ll have the skills and knowledge needed to identify code quality problems and correct them with quick and reliable refactoring techniques.

This course is a streamlined update of my 8-hour Refactoring Fundamentals course, which had older branding and IDE versions in it that required it to be updated. Also, not many developers had the endurance to complete an 8-hour course, so this one clocks in at a little over 2 hours.

SOLID Principles for C# Developers

It’s easy to write software that fulfills its users’ immediate needs, but is difficult to extend and maintain. Such software becomes a burden for companies striving to remain competitive. In this course, SOLID Principles for C# Developers, you will learn five fundamental principles of object-oriented design that will keep your software loosely coupled, testable, and maintainable. First, you will see how to keep classes small and focused, and how to extend their behavior without having to edit their source code. Then, you will discover the importance of properly designing interfaces and abstractions in your systems. Finally, you will explore how to arrange dependencies in your system so different implementations can be added or plugged in as needed, allowing a truly modular design. When you are finished with this course, you will understand how to build maintainable, extensible, and testable applications using C# and .NET.

This course is an update of my most popular course, SOLID Principles of OO Design, which was published in 2010. It streamlines the content a bit and leaves out the modules on the DRY principle, so check out the original course after this one if you want a little more depth.

Microsoft Azure Developer: Refactoring Code

Building Azure applications that last requires an understanding of software quality and maintainability. In this course, you'll learn how to recognize technical debt in your apps and how to refactor your code without starting from scratch.

This is a more focused version of my much more comprehensive course, Refactoring Fundamentals.

ASP.NET Core Quick Start (retired)

This course offered a quick introduction to ASP.NET Core so that you can be up to speed and productive in short order. It covers installation, app startup, middleware, dependency injection, MVC and Web API, diagnostics, testing, and architecture.

"ASP NET Core Quick Start goes beyond the basics into middleware, automated testing and clean DDD architecture

— Kevin O’Shaughnessy (@OshaughnessyKev) June 12, 2017

Pair Programming

Learn the basics and benefits of effective pair programming, including what not to do. This technique can greatly improve the quality and readability of your code as well as increase knowledge-sharing. You’ll start by learning about the different roles of pairing, when and when not to use paired programming, and several pairing techniques. From there, you’ll go over research that describes the benefits of this practice and learn about a similar technique called mob programming. Finally, you’ll discover how you can set up your workspace for success and how to do pair programming remotely. By the end of this course, you will know the proper techniques and benefits of pair programming, and you’ll be able to use it to your advantage to create better code.

Domain-Driven Design Fundamentals

This course teaches the fundamentals of Domain-Driven Design (DDD) through a demonstration of customer interactions and a complex demo application, along with advice from Eric Evans. It’s co-taught with Julie Lerman.

Refactoring Fundamentals

In this course you will learn when and how to refactor code in order to improve its design and internal quality. You'll learn about a wide variety of code smells, including how to recognize and correct them when necessary. Finally, the course demonstrates how to apply the principles and techniques covered in a hands-on exercise by completing a refactoring code kata that you can then practice yourself.

SOLID Principles of Object Oriented Design

This course covers what I feel are fundamental principles of writing object-oriented software applications. Included here are the SOLID principles as well as the Don’t Repeat Yourself principle, with lots of hands-on coding and examples showing the pain points and the refactorings to alleviate them. I highly recommend it if you are building applications using C# or VB.NET (or Java). I also recommend as a companion book that you consider Robert C. Martin’s Agile Principles, Patterns, and Practices in C#.

Creating N-Tier Applications in C#, Part 1

This course describes how to build multi-tier applications using C# and a variety of Microsoft development technologies. This first part introduces the concepts related to N-Tier application design, logical and physical separation of concerns, and then demonstrates how to separate application logic in two different ways. In the first example, a data-centric approach is taken to this separation, which was a very common “best practice” approach for many years, especially in the Microsoft development space. In the second example, a domain-centric approach is taken, resulting in a more testable and loosely-coupled application design.

Creating N-Tier Applications in C#, Part 2

Part 2 of creating N-Tier applications in C# focuses on three topics that I’ve found to be very important in these kinds of applications: testing, persistence, and reuse of core domain logic. This course also expands on some more Domain Driven Design principles and topics, as this style of programming has greatly influenced how I write such applications.

Design Patterns Library

The design patterns library includes over 10 hours of course material from a number of contributors covering many of the patterns described in the classic Gang of Four book Design Patterns as well as Martin Fowler’s Principles of Enterprise Application Architecture. If you’re just getting started, some of these may be a bit advanced for you, but I assure you there are patterns here that will be valuable to developers of all skill levels.

Web Application Performance and Scalability Testing

This course describes the principles of web application performance and scalability, and how to measure these capabilities using Visual Studio’s web and load testing tools. I know many developers believe this kind of performance testing is a dark art, and I hope that this 3+ hour course helps to eliminate the fear and encourage more developers to test their applications’ performance, since I know many have the tools already but just don’t know how easy it is to get started using them. For more on this topic, I recommend you look at my friend Paul Glavich’s book on the topic, .NET Performance Testing and Optimization – The Complete Guide.

Kanban Fundamentals

This is an introductory course on kanban, a fundamental component of Lean. In this course I look at the history of kanban and its use in the real world in both manufacturing and consumer environments, and then provide the basics for getting started with using kanban principles to improve your personal or team effectiveness. I expect to create a follow-up course in the future that will go into more depth on applying kanban to existing teams and integrating it with common agile practices like Scrum.