Pre-cons (October 23, 2023):

  • Building cloud-ready, resilient systems in .NET

    You may think that your application is already cloud-ready, it’s deployed in the cloud isn’t it?!
    But in truth, if your application is hard to monitor/scale/release/maintain, lacks resiliency, and is poorly structured, then it’s not “cloud-ready”.

    So what does “cloud-ready” actually mean?

    A “cloud ready” application is a legacy software application that has been modified to run on cloud computing infrastructure.

    Whether you are looking at a modular monolith or a full-blown distributed system, building a cloud-ready, resilient application is a must.

    In this workshop, we will look at the requirements for Tacky Tacos. A fictional taco business that’s thriving and wishes to expand.
    We’ll look at all the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking.
    We’ll then move on to actually building out a functioning, all-be-it, contrived application in .NET 7 and C#, learning as we go.

    ## Topics we’ll cover:

    – Architecture and Methodology
    – Modular monolith vs microservices vs SOA
    – The “12 Factors” and what they are
    – Distribution and Modularisation
    – Common design patterns
    – Modelling requirements
    – Practical: Code kata for tacky tacos

    ## Implementations

    ### .NET 7 application development recap
    – Dependency Injection
    – HttpClientFactory
    – Good practices

    ### External Configuration
    – What it is and why it is useful
    – Practical: implement external configuration with

    ### Databases
    – Why separate DBs may be required
    – Eventual Consistency
    – DB options – SQL, Document, Table, Blob, Serverless
    – Practical: Create two distinct databases – later these will employ “eventual consistency”

    ### Synchronous communication
    – Introduction to synchronous communication and when to use it
    – Synchronous options
    – Practical: build an HTTP endpoint for a web client
    – Practical: implement gRPC to communicate with a non .NET application
    – Practical: implement a hub with SignalR to broadcast real-time information

    ### Asynchronous communication
    – Introduction to asynchronous communication and when to use it
    – Message brokers
    – Implementation considerations
    – Error handling
    – Choosing a message broker
    – Practical: Implement a pub/sub with RabbitMQ

    ### API gateways and BFF
    – Introduction to the use cases and considerations
    – When to use BFF
    – Practical: API Gateway with YARP

    ### Load balancing
    – What it is and why we need it
    – Practical: Add load balancing to YARP

    ### Service discovery
    – What it is and why we need it
    – Practical: set up Service Discovery using Steeltoe and Eureka
    – Practical: Integrate Service Discovery with YARP API gateway

    ### Resiliency
    – What makes an application resilient?
    – policies, circuit breakers, fallbacks and retries
    – Practical: implement policies with Polly

    ### M2M Authentication
    – Why it’s needed
    – Practical: Implement M2M authorization with Auth0

    ### Monitoring, tracing, observability
    – What is it and why do we need it
    – What is the OpenTelemetry project
    – What tools are available
    – Practical: Implement various endpoints and actuators with Steeltoe

    ### Serverless
    – When to use a serverless function and why
    – Practical: create an Azure Function service

    ## Who is this workshop aimed at

    This workshop is aimed at backend developers with some experience writing web applications using C# and .NET.
    The workshop will not cover .NET Framework.

    ## Equipment and software
    – A computer – either Windows PC or macOS (I have no experience with Linux so if you bring a Linux machine my problem-solving will be limited)
    – Visual Studio 2022 or JetBrains Rider or VS Code
    – .NET 7
    – Docker Desktop

    • From Zero to Hero: Unit & Mutation testing in C#

      Testing is an absolute must when building reliable software. It allows us to make code changes with minimal risk and ensures that bugs or problems within our codebase are caught early before they can impact customers. It can also let us know how our application performs under pressure and we can use that information to optimize what matters. This workshop will get you started on the right track and teach you all the best practices you need to know to write clean and effective unit and integration tests in .NET with C#. It will also introduce you to the concept of performance testing and get you started testing how your applications perform when pushed to their limits.

      In this first part of the workshop we are going to cover the following topics:

      – Understanding the different types of testing
      – Introduction to Unit testing
      – Mocking
      – Fakes
      – Assertions
      – Creating test data at scale
      – Creating realistic test data
      – Testing “untestable” code
      – Code coverage
      – Measuring code coverage
      – The value of code coverage
      – Introduction to Mutation testing

      • Reliable Messaging with Azure

        In this workshop, attendees will learn the fundamentals of reliable messaging with Azure using examples in C# .NET.

        We will start from using Queue Storage as a simple, cost-effective and durable message queue to effectively decouple components and increase the resilience as well as scalability.

        Once familiar with the simple queuing technology, we will dive deep into the feature rich Service Bus that provides all the bells and whistles for building robust and reliable applications leveraging the publish/subscribe pattern.

        We will end the day with a sneak peek at Event Hubs that allows streaming millions of events per second to build real-time data ingestion services.

        Armed with the knowledge of these three reliable messaging services in Azure, you’ll have a good understanding of the benefits and usage scenarios to clearly distinguish when to use what. Furthermore, you will have had the first practical experience in writing reliable code against those services, giving you a head-start for your career building reliable messaging solutions in Azure.

        This is a Bring Your Own Device (BYOD) course. At BYOD courses, delegates are required to bring their own laptop with the necessary software installed. To use Azure services, including Service Bus, you’ll need a subscription. If you do not have an existing Azure account, you may sign up for a free trial ( or use your Visual Studio Subscription ( benefits when you create an account (

        Session and Speaker Management powered by