I put together a number of workshops that I can deliver for you and your team on request. They come with a specific set of contents, but I can always customize the agenda to meet your specific needs, if you so desire.

All workshops include a Q&A session. In order to get the most out of it, I encourage you to email me your questions beforehand. That will help me get a sense for where you stand on the topic and identify any particular areas where to put extra emphasis during the workshop.

If you'd like to know more, don't hesitate to contact me.


Here's a list of my upcoming public workshops. Please, follow the link to the event's page for availability and bookings.

On demand — Online 🌍

Building a Deployment Pipeline with C# and Cake
2 Days

Remember when most web applications were just a website and a SQL database? Yeah, things are different these days. Modern web applications consist of an ever increasing number of moving parts: JavaScript frontends, web APIs, microservices, cloud environments—the list goes on. Building and deploying these applications involves joggling a complex set of tools and services—each with their own rules and requirements—and make them all come together in a unified process. On top of that, modern development teams are expected to release software often, which means that those processes must be entirely automated, from source code to production servers.

As a .NET developer living in a DevOps culture, how do you achieve that without having to invest in learning a whole new set of tools and languages? Meet Cake. Cake is an open source cross-platform build automation tool with a surprisingly rich ecosystem of integrations to third-party tools and services. And the best part is: it uses a beautiful C# DSL that will make you feel right at home.

What You Will Learn

In this workshop, you will learn everything you need to know to automate a complete build and deployment pipeline for a modern ASP.NET Core 3.0 web application using nothing more than C# and Cake.

You will know how to apply your existing C# and .NET skills to automate a modern build and deployment pipeline — as a bonus, you'll also learn how to write maintainable build scripts that can adapt as the needs of the software change.


  • Compiling using MSBuild and the .NET Core CLI tools
  • Running automated tests and measuring code coverage
  • Versioning based on the Git history of the project
  • Packaging with NuGet or as regular Zip files
  • Publishing the application as a Docker container
  • Deploying to an on-premises web server using Octopus Deploy
  • Deploying to an Azure Web App using Kudu
  • Deploying to a containerized Azure Web App using Docker and the Azure Container Registry
  • Integrating with CI servers such as TeamCity, Azure DevOps and GitHub Actions
  • Troubleshooting the pipeline with logging and debugging


If you're a C# developer who wishes to set up a Continuous Integration/Continuous Delivery pipeline without having to learn a completely new set of tools and languages, then this workshop is for you. You'll be able to apply your hard-earned knowledge of the .NET platform to the world of build and deployment automation. If you've worked with other Make-like build automation tools before, that's great. If you haven't, don't worry — we'll cover the basics of how to write a solid build script.

Understanding Git — Behind the Command Line
1 Day

Git has become the de-facto version control system of our industry, and for good reason. What you're able to achieve with Git is unmatched by any other version control system that came before it. But for all its power and flexibility, Git has a terrible flaw: its complexity. A myriad of awkwardly named commands and options, have earned Git the reputation of being hard—and unnecessarily so—both to learn and to use.

You won't find me arguing with that. In fact, I, too, question whether we need that many options and, most of all, I have my reservations about some of the name choices.

However, I don't believe that Git is hard to understand. In fact, it's quite the opposite — Git is surprisingly simple at its core. If you don't believe me, open up Git's manual page by typing man git in your favorite command-line shell. If you take a look at the very first paragraph, you'll see this:

git — the stupid content tracker

It says it right in the tagline. Git is nothing more than a simple, yet very efficient, content tracker for your files. The key to unlock its power and flexibility is to understand it at a fundamental level. And I found that the best way to do so is by actually seeing what's going on behind all those cryptic commands and options.

That's exactly what this workshop is about.

What You Will Learn

In this workshop, you'll learn Git from the inside out; you will understand how the different commands work by watching a real-time visual representation of Git's internal object model.

Each time you run a common operation like creating a branch, merging or rebasing, you'll immediately see how it affects the underlying history of your repository. This will give you a useful mental model of how Git works. Once you have that, all of the magic will disappear and you'll finally be able to make Git work for you instead of the other way around.


  • The Git Parable
  • Git's object model
  • Anatomy of a commit
  • Customizing the way you view history
  • What the index is and what it's good for
  • Branching, a visual explanation
  • Rebasing, a visual explanation
  • Different kinds of branches
  • Different ways of merging
  • Branches vs. Tags
  • Resolving conflicts
  • Choosing a Git client that works for you


This workshop is designed for developers who have little to no experience with Git. The only prerequisite is that you're somewhat familiar with using a command-line shell for your operating system of choice. During the workshop, I'll show you how to interact with Git from either PowerShell or Bash.

Note that you don't have to keep using the command-line after the workshop if you don't want to; we'll use it as a learning tool to understand how Git works. Once you master the concepts, you'll be able to choose any Git client of your liking and make the most out of it.

Mastering Git — Beyond the Command Line
1 Day

You've been using Git for a while and feel pretty comfortable with the basics: committing, creating branches, merging — you got that. However, something is missing; maybe you feel you're not taking full advantage of what Git has to offer; maybe you occasionally end up with an entangled history and would like to know how to avoid that. You want to know more. If this sounds like your situation, then this workshop is for you.

Mastering Git is about going beyond the basics and learn to truly unleash the power of Git to support your working style, both individually as well as within your team.

You will discover that Git is so much more than simply branching and merging; its unique features are designed to allow you to take care of your project's history while, at the same time, enabling new forms of collaboration. And that's not all: along the way you'll pick up a few tricks that will directly improve your personal day-to-day workflow.

What You Will Learn

The goal of this workshop is to teach you to take advantage of the unique features that set Git apart from the other version control systems.

You'll start out by learning the value of keeping a clean history and how Git was designed to let you do just that. You'll become aware of what makes a good commit and how you can apply those principles to your project. We'll also discuss the pros and cons of rewriting commits and the eternal debate of readable history vs. true history.

Next, you'll learn about the different branching strategies (like GitFlow and GitHub Flow), their advantages and disadvantages and when it makes sense to use one or the other in a given project. You will also learn how to use submodules to manage the dependencies between different projects.

Along the way, you will also pick up a few techniques that will make your personal workflow more efficient; among other things, you'll learn how to use the reflog to recover seemingly lost commits, how to work on different tasks in parallel by keeping multiple working directories and how to quickly find the commit that introduced a bug by doing a binary search.


  • The importance of keeping a good-looking history
  • ACID commits
  • Ensuring consistent line-endings and whitespace
  • When and how to rewrite history
  • The many ways to use git-rebase
  • Choosing a branching strategy for your project
  • GitFlow vs. GitHub Flow vs. Your Own Flow™
  • Managing dependencies between projects with submodules
  • Searching history
  • Recovering lost commits
  • Reusing conflict resolutions (git-rerere)
  • Managing multiple working directories (git-worktree)
  • Debugging (git-bisect)
  • Taking care of your repository (git-gc)


To get the most out of Mastering Git, you should feel confident with Git's fundamental concepts. If you'd like to strengthen your knowledge in that area, I highly recommend that you take Understanding Git first and have this as a continuation; both workshops complement each other nicely, since they share the same visualization techniques to explain the concepts.

You should also be familiar with handling a command-line shell. During the workshop, I'll use either PowerShell or Bash, based on your preference.


If you'd like to have a workshop at your company or event, you can find more information on how to reach me on the contact page