Workshop Prerequisites

Attending the KCDC pre-conference workshops? Then read below to see what prerequisite tools, software, skills, or general knowledge you should have before attending each of our half- and full-day workshops on offer this year. Check out the full schedule of sessions on our agenda page.

Full-Day (8am – 5pm)

Systems Thinking Workshop - Visualizing Relationships and Knowing Where to Act
Joel Tosi and Chris Pipito
Room 2201

Abstract:

In this hands-on workshop, attendees will learn how to model systems and look for leverage points as means of introducing intentional, impactful change in an organization.

The workshop will cover:
- Systems Diagramming (Nouns, Verbs, Reinforcing, Balancing Loops)
- Types of leverage points and identification
- Value Demand / Failure Demand
- Determining areas of change where 'good enough' is enough
- Separating signal from noise - knowing your changes made a difference

This workshop is designed for anyone that is interested in helping teams and organizations be more effective and worry less about 'the process'

Prerequisites:

Attendees will need to bring a laptop or tablet with a browser on them. They should be able to run the workshop on a VPN or firewall - that hasn't been an issue in the past, but just to be safe.

Attendees will work in pairs or groups of 3 and really only 1 device is needed for the group.

•••

.NET Aspire and Dapr: a microservices match made in heaven
Nico Vermeir
Room 2202

Abstract:

Microservices are great but they bring their own challenges. The distributed application runtime, or Dapr, already solves quite some problems, but there is a new kid on the block. With. NET Aspire you get a neat dashboard, open telemetry tracing by default and much more.

Join me in this full day discovery of where Dapr and Aspire compliment each other, fight each other or when to choose which flavor.

By the end of this workshop you will have the tools you need to successfully setup a microservices architecture, and you'll know how to choose between Dapr or Aspire on its own, or how to use them together.

Prerequisites:

- Bring a laptop powerful enough to build and debug .NET applications while containers are running (MacOS should work, but the workshop is build and tested on Windows)
- Attendees should be able to install software on their machine (local admin or equivalent)
- Docker installed and configured, please check you can run a container before the workshop
- Have Git installed
- Have Visual Studio or Rider installed with the .NET 9 SDK and ASP.net workload

•••

The Cheat Code to Avoid Ransomware and Data Breaches with SQL Server
John Sterett
Room 2203

Abstract:

After this workshop, even your DBAs cannot see your sensitive data!

Buckle up. You will gain real-world experience through instructor-led hands-on labs that build a web application focused on securing your application's data layer using SQL Server's advanced security features.

The day starts by exploring Data Discovery and classification tools to identify and categorize sensitive information. Next, we dive into column-level encryption by implementing Dynamic Data Masking and Always Encrypted, including scenarios using secure enclaves for improved query performance. Next, we will cover Row-Level Security to control data access and visibility. I will cover auditing so we can track all access points of your classified data. The day will end with you having a proof-of-concept application that will keep your data safe and make your security auditors happy!

Prerequisites:

You will learn a lot in this workshop. To make the class content more meaningful, exercises are planned as part of the class; please bring your laptop and have the following items installed and ready to go.

You will need to access the following on your laptop:

  1. SQL Server Instance (SQL Server 2022 or SQL Server 2025) with a login with sysadmin access on your laptop.

    1. SQL Server 2022 CU20 (latest cu)

    1. SQL Server 2025 CTP 2.1 can be downloaded from https://www.microsoft.com/en-us/evalcenter/sql-server-2025-download

  2. SSMS 21 can be downloaded from https://aka.ms/ssms/21/release/vs_SSMS.exe

  3. SSMS 18.12.1 is required for Vulnerability Assessment Exercise. Can be located at https://go.microsoft.com/fwlink/?linkid=2199013&clcid=0x409

  4. Sample databases

  5.  Download the Github Repo for the lab examples. 

    https://github.com/johnsterrett/security-workshop-demos/archive/refs/heads/main.zip

•••

Shift left quality using BDD right
Martijn Goossens
Room 2207

Abstract:

True Shift-Left testing starts before a new sprint. Behavior-driven Development (BDD) is a method that can achieve this by helping teams communicate better with their stakeholders and amongst each other regarding their delivery. Using the technique of Example Mapping, teams work with their PO to get to actionable scenarios and examples of the functionality they want to build. These examples become your tests, documentation, and the ultimate form of shifting left.

We will briefly discuss the background and principles of behavior-driven development and how to apply those. Soon into the workshop, the interaction will start in groups where we will look at the concepts of 'Rules' and 'Examples'. We will play with and practice Example Mapping, a technique that helps you break down and slice your user stories into practical scenarios. You will discover how these can be used directly as your tests and documentation for your team and a few different formats to apply these in. As the final takeaways, you'll learn how to facilitate better refinements with your teams to deliver optimal business value and complete your sprints with less rework and bugs.

Quality at the start will facilitate quality in the rest of the process and with this workshop you will be leveling up your Shift Left approach with applicable skills.

Takeaways:
What Behavior-driven development (really) means and that it’s not the Gherkin you might have used before
A practical application of use Example Mapping, a BDD technique, to discover requirements, test cases and hidden assumptions
Ways to address shift-left and BDD in your organisation
Tips to power-up your refinements to start with quality before your sprints start

Prerequisites:

This workshop is a hands-on session where you won't need a laptop. Better yet: don't bring one for the day as I'll ask you to close it anyway to focus on the session.
You could bring a notepad or something to make notes on. I'll share the informational slides afterwards, though you might have brilliant ideas as we go that you might want to write down.

•••

[Workshop] Kubernetes hands-on
Rob Richardson
Room 2208

Abstract:

Kubernetes is how you run Docker in production. Bring your laptop with Docker for Windows or Docker for Mac edge version installed. We'll walk through getting a K8s cluster fired up on Docker-Desktop, minikube, and on Azure. You'll be hosting Docker containers in development and production in no time. We'll dig deep into:

- A quick tour through Docker concepts
- The components of a kubernetes cluster
- pods, services, deployments, and replicas
- ways to scale and expose/isolate your containers
- public and private container registries
- stateful containers
- promoting from development to production
- Azure Container Service (AKS)
- Best practices for building at cloud scale
- Tips & Tricks for leveraging Docker and Kubernetes
- When not to use Kubernetes

We'll look at the commands and ecosystem around building infrastructure as code, local and cloud clusters, and best practices with containers. Come see why devs and ops love Kubernetes.

Prerequisites:

Hi friend,
I’m excited you’ll join us for the Kubernetes workshop at KCDC.  I’m excited we’ll get to learn together.  For this workshop, you’ll need a laptop with Docker Desktop installed and configured.  You could use Podman, Minikube, or another Docker alternative, but you may need to adapt the instructions slightly.

To make this workshop a success, there’s a bit of setup you’ll need to do before you arrive:

1. Install and update Docker Desktop.
2. In the settings, turn on Kubernetes Mode.
3. Pull a few images we’ll use during the event.

 You can find the full instructions in chapter 0 at https://github.com/robrich/kubernetes-hands-on-workshop/tree/main/00-Install#readme

Then on the day, bring your laptop, and we’ll have a lot of fun.  Can’t wait to see you there!

Rob

•••

Mastering Micro-Frontends
David Nicholas and Jennifer Wadella
Room 2209

Abstract:

Dive into the world of Micro Frontends in this dynamic 8-hour workshop designed for intermediate and advanced developers. Through a mix of theory and extensive hands-on practice, including a comprehensive e-commerce project, participants will explore integrating various technologies within a Micro Frontend architecture. This workshop will not only clarify the complexities and challenges of Micro Frontends but also equip you with practical strategies for overcoming them. Expect to emerge with a solid grasp of Micro Frontend principles and ready to implement scalable and flexible solutions that enhance development workflows and product quality. This workshop is perfect for developers who master advanced architectural patterns to address sophisticated business and team requirements.

Prerequisites:

For the workshop, you will need a computer with Node (v22), npm, and git installed—a Mac or Windows—either will be fine. I will be using a Mac.

If you haven’t set up Node or NPM before, I recommend using the Node Version Manager (NVM). It’s a version manager that lets you switch between different versions of Node and NPM together. This article explains how to set it up on Windows and Mac. As for git, the docs have a good summary.

If you have Node, NPM, and Git (or after you’ve set them up), it will be helpful to install NX, which you can do following the docs under the Installing Nx Globally section link.

You do not need to create an Nx workspace or project or be familiar with Nx beforehand. We will be using NX to simplify running many applications simultaneously, and the commands you’ll need to know will be discussed in the workshop.

I highly recommend downloading everything in advance.

•••

Half-Day Morning (8am – 12pm)

Safeguarding SLAs with Resilient Systems: Chaos Engineering Unveiled
Siddharth Vijay
Room 2204

Abstract:

In this session, attendees will learn:

- Understanding Chaos Engineering: Discover how intentional failure injection can help identify and address vulnerabilities in complex systems.
- Safeguarding SLAs: Learn strategies to ensure Service Level Agreements (SLAs) are consistently met, even under adverse conditions.
- Building Resilient Architectures: Explore practical methods for designing systems that can recover gracefully from unexpected disruptions.
- Real-World Applications: Gain insights from case studies of a gaming application serving 20Mn+ request every day demonstrating how chaos engineering probes enhance system reliability and user experience.

Prerequisites:

You don’t need to bring any laptop setup to the session. However, for trying the experiments later at your own pace, here’s what you should have in place:

1. Basic Knowledge

  • Comfortable with containers (Docker) and Kubernetes basics

  • A general understanding of production system components (microservices, APIs, infra)

2. Environment (for later use)

To try chaos experiments later, you may set up the following:

  • A Kubernetes Cluster (cloud-managed like EKS/GKE/AKS)

  • kubectl installed and configured

  • Helm (for installing LitmusChaos)

  • Access to deploy simple test applications (e.g., a demo HTTP service or sample microservices)

  • Python or Bash scripting knowledge is a plus (for experiment automation)

What You’ll Receive Post-Session

After the workshop, you'll get:

  • Slide deck (PPT & PDF)

  • Lab guide for implementing chaos experiments in your own setup

Optional Preparation (Before Workshop)

If you're new to Chaos Engineering and want to prep:

•••

Optimizing Next.js Applications with React Server Components and Server Actions
Adhithi Ravichandran and Avindra Fernando
Room 2205

Abstract:

Your React app built with Next.js works, but is it truly optimized for performance? Slow load times and inefficient data handling can impact user experience and scalability, leading to frustrated users and higher infrastructure costs.

In this hands-on workshop, we will start with a Next.js application that lacks modern performance optimizations and gradually enhance it by implementing React Server Components (RSC) and Server Actions step by step. You will see how RSC reduces JavaScript bundle sizes, improves interactivity, and enables progressive rendering, while Server Actions make data updates more efficient by minimizing client-server communication.

Through guided demonstrations, we will transform the app from a traditional Next.js setup into an optimized, fast, and scalable application. By the end of the session, you will have a clear understanding of how to apply these techniques in your own projects to build faster, more responsive, and efficient Next.js applications.

Prerequisites:

Prerequisite Knowledge: To attend this workshop, you should have some knowledge of:

  • Modern JavaScript Features

  • CSS and HTML

  • TypeScript

  • React

  • No previous experience with Next.js needed

Prerequisite Equipment:

  • Operating systems: macOS, Windows (including WSL), or Linux.

  • Bring your laptop, and it should be able to connect to the local conference WIFI.

Required Versions

  • Node.js: v22.14.0

  • (Requires Node.js v18.18 or later)

  • npm: v8.x or later

  • React: v19.0.0 (Part of project repo)

  • Next.js: v15.4.3 (Part of project repo)

Installation

  • Node.js LTS version: https://nodejs.org/en/download/

  • Package manager. We will use NPM (comes included in Node.js), but you can also use Yarn: https://yarnpkg.com/

  • If you do not have one already, create a GitHub account: https://github.com/ (We will be cloning our repository on GitHub for the workshop, and follow along for exercises, so ensure that you have a GitHub account already created.)

  • Create a Vercel account: https://vercel.com/ (If you want to deploy your code)

  • Install Visual Studio Code IDE: https://code.visualstudio.com/

Clone and Prepare the Starter Repo

Once you are done with the installation of the above, you can also checkout the starter-code branch from the repo and install the dependencies from the package.json file. This might be useful, because at times the conference venue has slow WIFI, and this could

speed the setup.

git clone https://github.com/adhithiravi/Next.js-Workshop/tree/starter-code

cd Next.js-Workshop

npm install

npm run dev

Visit http://localhost:3000 to confirm you see the baseline Bethany’s Cafe UI (no performance optimizations applied yet).

•••

Zero to Design System (in just 4 hours)
Kathryn Grayson Nanz and Alyssa Nicoll
Room 2206

Abstract:

Been curious about these "design system" things, but not exactly sure where to start? Want to level up the unity and cohesiveness of your app design, but working without a designer? Feel like your team would benefit from a single source of truth for your UI, but haven't had the time to put one together?

Design systems can solve a lot of problems, but they do require some dedicated time and effort to get off the ground. In this workshop, we'll walk through that setup process together (leveraging a variety of free tools) – and you'll take home a basic design system to help kick off your journey on a strong foundation.

Prerequisites:

We’re so excited that you’ll be joining us for the workshop. In order for us to make the most of our time together, please complete the following before you arrive:

Create a Telerik Account:

A Telerik account is required to use some of the tools – don’t worry, we’ll only be using free versions or trials. Sign up here: https://www.telerik.com/account/

Install the Following:

  • A modern code editor (e.g. VS Code), a web browser (e.g. Chrome, Safari, etc.), and a terminal (either the one in your IDE, your native terminal, or something like iTerm) to edit, run, and view your React or Angular application.

  • Git, to clone our sample repo to work on locally.

  • Npm (setup and ready to use) to npm install dependencies and components.

  • If you wish to work in Angular: the Angular CLI (npm install -g @angular/cli) installed and ready to use.

Refresh your skills:

You will need some familiarity with React or Angular (enough to run an app and understand components), as well as enough CLI familiarity to run basic installs and commands (e.g. git clone, npm i, npm run, ng serve, etc.).

Find your brand guidelines / style info (if applicable):

If you have an existing brand you want to use, bring as much documentation about the styles as you can! If you don’t want to use a pre-existing brand, you can make those design choices yourself during the workshop – or try out ThemeBuilder’s AI Theme Generator tool.

If you want to use existing brand guidelines, consider:

  • Brand colors (e.g. hex, rgb values, etc.) and typography (sizes, font, etc.).

  • Details like border radius, spacing, icon fonts, error / info / warning states, common design patterns, etc.

  • If you don’t have something, don’t worry – we’ll fill it in during the workshop (and this is just meant to be a starting point, anyway) 😊

•••

GitHub Actions: From Zero to Hero Workshop
Scott Sauber
Room 2210

Abstract:

Continuous Integration and Continuous Delivery (CI/CD) pipelines are now table stakes and an expectation in modern software development teams. GitHub Actions have become the dominant player in the CI/CD space, due to their convenience and tight integration with the world's most popular version control platform - GitHub. In this workshop, we will start from the ground up and teach you how to build robust pipelines using GitHub Actions.

Some things we will cover:
- What is CI/CD
- What should be in everyone CI/CD Pipeline
- How to create a GitHub Action
- Defining GitHub Actions terms such as workflows, triggers, jobs, and steps
- How to create a GitHub Action running as a cron job
- Dealing with variables and secrets
- Reusing workflows across multiple repositories to promote reusability and standardization

We will have a mix of instruction and hands-on work. By the end of this workshop, you should have all the tools and knowledge you need to be productive with GitHub Actions at your company.

Prerequisites:

There are only a few requirements:

  • Laptop

  • Git installed: https://git-scm.com/downloads

  • GitHub account (sign up here): https://github.com/signup

  • An editor of some sort (I'll be using VS Code in the demo)

•••

Refactor Java with Confidence Workshop
Steven Diamante
Room 2211

Abstract:

Refactoring isn’t just cleanup. It’s how great developers keep code fast and flexible.

If you’ve ever struggled with messy logic, confusing names, or code that’s hard to change, this hands-on workshop will level up your refactoring skills.

What we’ll cover:
- Refactoring fundamentals: what refactoring is, when to do it, and why it matters
- Testing for safe refactoring: using Approval Testing and Mutation Testing to prevent regressions
- Small wins, big impact: techniques like renaming, simplifying logic, and improving structure
- Decoupling code for maintainability: separating business logic from I/O for cleaner, more adaptable systems

Expect plenty of coding, guided exercises, and practical takeaways you can apply immediately. Whether you’re new to refactoring or looking to sharpen your expertise, this workshop will give you the confidence to refactor fearlessly.

Prerequisites:

  • Laptop with internet access

  • Git installed on machine

  • Repo: https://github.com/SDiamante13/legacy-trivia

  • Java 17

  • IntelliJ or preferred IDE

  • Collaborative attitude as we will be working together in small groups

  • Basic Java knowledge (or similar OO language) 

•••

From Ideas to Action: A Hands-On Innovation Workshop
Brian Zimmer and Bill Udell
Room 2214

Abstract:

Every innovation starts with a person and an idea—but most early ideas won't ultimately succeed. How do you quickly assess, refine, and validate an idea so it either gains traction or fails fast so you can move on to the next one?

In this interactive, fast-paced workshop, you’ll bring your own idea for a startup, product, or feature and work through a series of activities to:

1. Expand your perspective and add structure to your idea.
2. Explore new possibilities by generating ideas you hadn’t considered.
3. Assess desirability, feasibility, and viability to refine your concept.
4. Identify concrete steps to bring your idea closer to reality.
5. Tap into the collective intelligence of the room to accelerate your progress and maximize your experience at KCDC.

Whether you’re tech lead shaping a new feature, a senior developer with a side project, or a manager fostering innovation in your team, this workshop will equip you with the tools and insights to move from idea to action and help others do the same.

Prerequisites:

To get the most out of this session, come prepared with a real-world problem and a potential software solution idea that addresses it. Ideally, this should be a challenge you’re familiar with, having domain knowledge will make the work more meaningful and grounded. We encourage you to choose something complex or ambiguous rather than a simple or well-defined problem. The messier, the better—we’ll be diving into critical thinking and exploration.

Please also bring a laptop (and optionally, a mouse) as much of our work will take place individually in FigJam via a web browser. You will complete activities individually and share back with others for feedback.  You may also optionally pair up with someone you know if you are working on the same problem.

•••

Building AI Using AI
Shashank Daté
Room 2215A

Abstract:

This workshop is for intermediate to advanced level software engineers who want to dip their toes in the AI ocean by building a small AI based system, using AI. No prior knowledge of AI is needed. But a good understanding of building software systems is a prerequisite. The workshop will be conducted using Python as the programming language of choice, but support will also be provided for Ruby and Javascript. Attendees will be expected to bring their own device (Mac, Linux, Windows) which has at least 8 GB of RAM and 60 GB of free disk space. There will be four sub-sessions, about 1 hour each:
1.⁠ ⁠Intro and ⁠Set up: intro to various AI/ML terms and prepare your device with necessary tools needed for the workshop.
2.⁠ Graded ⁠AI Coding exercises: using various local and cloud based APIs
3.⁠ ⁠Building a RAG application: a fast paced tutorial of how to build a Retrieval-Augmented generation model, using AI generated code
4.⁠ ⁠Getting started with Fine-tuning: learn how to configure the model and the training loop on a resource rich cloud platform

Prerequisites:

1. Signup for Github Account and navigate to https://github.com/shanko/kcdc-2025

2. If you are on Windows, install WSL2 and then follow the remaining instructions in the installed Linux distribution.
3. Install Python version 3.10 or above with following packages:
   - langchain
   - langchain-chroma
   - langchain-community
   - langchain-core
   - langchain-ollama
   - langgraph
   - ollama
   - pandas
   - pip
   - torch
   - transformers
4. Install Ollama on your laptop which should have at least 16 GB of RAM and 50 GB of free disk space

Optional:
1. Install Windsurf
2. Signup for a Google Colab Account
3. Signup for a Lovable Account
4. Signup for a Huggingface Account

•••

Data Structures Crash Course
Jordan Thayer
Room 2215B

Abstract:

Who among us hasn’t felt the pain of using a dictionary or list instead of a more fit-to-purpose data structure because it was easy and available? Have you ever wondered how exactly a hashtable works, or why people sometimes call a heap a treap? Have you ever heard of Big O and Big 𝚯, and if you have, do you remember what they are?

Many of us are from non-traditional backgrounds or bootcamps and may never have had an algorithms and data structures course, and the rest of us are years removed from the last time we studied the subject formally. As we advance in our careers as software developers, we keep getting further and further away from the fundamentals. That’s a shame because the fundamentals are useful in our day jobs, appear often as technical interview questions, and honestly they’re also really fun to poke at. It’s right there in the name!

This workshop is a refresher, or crash course, on the basic data structures and algorithms that underpin the software we build. We’ll focus on techniques for recognizing the structure of a problem, finding a relevant data structure to help solve it, and ballparking the cost of computing answers in terms of time and memory. We won’t be implementing structures from scratch. We’ll look at:

* Segmenting an image using the color of adjacent pixels to find edges
* The importance of good hashing through the lens of solving a Rubik’s cube
* Rapidly testing collision for all sprites in a video game field
* Efficiently finding similar items in a large catalog of items

Attendees can expect to come away with:

* Better familiarity with common data structures
* A process for identifying the correct data structure to solve a problem with
* A (re)-introduction to Big O & Big 𝚯 analysis

Prerequisites:

Technically, attendees need only bring themselves. The session is lecture based with some lite classroom participation sections.

Better than just bringing yourself is to come with pen and paper, because we'll be doing some back of the napkin math, and writing on actual napkins sucks.

If you want to play along as I run examples for the whole class, you may clone the following repository: https://github.com/DrSeabass/data_structures_big_o
You'll need a bog standard installation of python; the demo code relies on no additional libraries. To reiterate, cloning the repo is not required.

•••

Building reactive, multiplayer, full-stack apps with Python
Benjamin Hindman
Room 2215C

Abstract:

Most web and mobile apps benefit from being "reactive": if something changes in the backend, they can immediately show it in every connected frontend, without a page refresh. Reactivity is especially important if your app is "multiplayer": with multiple humans or agentic AIs interacting with each other via your backend - like chatrooms, dashboards, or collaborative editing, for example.

Building a reactive, multiplayer app with Python has been pretty complicated though. Hurdles include:
* How do you send events from the backend to the frontend (probably written in JavaScript)?
* How does your backend even know that there's events to send, especially if your app gets big enough to need multiple servers?
* How do you manage and safely change the state shared between frontends, ideally without writing yet more JavaScript?
* How do you safely serialize/deserialize Python objects for clients that may be running old code (backwards compatibility), while also keeping type safety?
* How can reactive APIs work if you also have clients that aren't JavaScript, for example other Python programs?

This workshop will use reboot.dev to show you how to build these reactive, multiplayer apps!

Prerequisites:

Attendees will need to be able to install Docker, which does require admin access, unless they have Docker already installed and can use it as a non-admin. You will need the ability to connect to the internet.

Required:

  • macOS or Linux

  • Terminal, can be integrated into your IDE

  • git

  • `uv` (https://docs.astral.sh/uv)

  • Python >= 3.10 and < 3.13, but if you don't have this installed don't worry we'll get it via `uv`

  • Docker

  • Node.js >=20.10 (`node` and `npm`, but you usually get both just by installing `node`)

Optional (but highly recommended):

  • An API key for either OpenAI or Anthropic or Gemini

  • An IDE such as VSCode

•••

Building Production-Ready AI Agents with Strands Agents
Du’An Lightfoot
Room 2104A

Abstract:

In this hands-on 4 hour workshop, participants will build production-ready AI agents using AWS Strands Agents SDK. You'll go from zero to production, creating sophisticated single and multi-agent systems that solve real-world problems.

Starting with a basic agent, you'll rapidly progress through essential concepts: integrating multiple model providers, connecting AWS services, implementing tools and Model Context Protocol (MCP) for extensibility, and adding responsible AI guardrails. You'll then dive into implementing observability and evaluation frameworks for production monitoring.

You'll leave with working code and the architectural knowledge to build AI systems that scale. Perfect for developers ready to move beyond basic AI integration into sophisticated agent-based solutions.

Prerequisites:

Basic Python knowledge and no AWS familiarity or account required.

Half-Day Afternoon (1pm – 5pm)

Mastering .NET Aspire: From Fundamentals to Advanced Concepts
Lukas Durovsky
Room 2204

Abstract:

Building modern, cloud-native applications presents significant challenges for developers. Managing complex interdependencies between microservices, ensuring consistent performance under varying loads, and debugging issues in distributed systems can be overwhelming. .NET Aspire provides a powerful framework that simplifies cloud-native development by offering a comprehensive set of tools and libraries for building resilient, scalable, and observable applications.

This workshop will guide you on a journey through the .NET Aspire ecosystem, starting with fundamental concepts and progressing to advanced techniques. By the end of the workshop, you'll have the knowledge and skills to confidently design and implement robust cloud-native applications using .NET Aspire.

After introduction to .NET Aspire we will be working on a sample-app. You will gain hands-on experience learning how to:
- build a complete sample application from scratch using .NET Aspire
- register and discover services within the .NET Aspire ecosystem
- integrate database (e.g. MS-SQL, MongoDB) & messaging (e.g. RabbitMQ) & containers into your system
- integrate Azure services (CosmosDB, Storage) into your system
- implement logging, metrics collection, and distributed tracing using OpenTelemetry
- build automated tests of the system
- deploy and manage .NET Aspire Applications

Prerequisites:

This workshop is "passive people friendly", so people still get a lot of information and skills even without trying things on their own. In such case, it is not necessary to have any of the prerequisites. 

---------------------------------------------------------

Software & utilities
1. Azure Developer CLI - https://learn.microsoft.com/en-us/azure/developer/azure-developer-cli/install-azd
2. .NET 9.0 (or 8.0, possibly also 10.0)
3. Visual Studio 2022 17.9 or higher / VS Code
4 .NET Aspire SDK
5. OCI compliant container runtime (Docker, Podman...)
- run command 'dotnet new update' at your machine
More info can be found here - https://learn.microsoft.com/en-us/dotnet/aspire/fundamentals/setup-tooling

Tools & Accounts
1. Azure account with subscription with appropriate permissions (create resources...)
2. MS SQL database, (e.g., local SQL / SQL Express server, Azure SQL Database...) & connection-string to this MS SQL database

Repository
https://github.com/xlukasd/WS-AspireApp - currently it is private, it will be available 2 days before the workshop

•••

Preparing for the Java 21 Certification with Hands on Training (or learning about new features)
Jeanne Boyarsky
Room 2205

Abstract:

In this workshop, I’ll be teaching exam topics added from Java 12-21 and helping attendees get hands on practice with certification type questions and coding. While it isn’t possible to be ready for the test in just a day, we’ll have covered some of the hardest parts and you’ll have a plan to be ready. Even if you don’t intend to take the test, this is an opportunity to get familiar with some of the trickier aspects of some of the new Java features.

Prerequisites:

Please bring a laptop to this workshop. While (most) of the lab can be done in a browser, you will have a better experience if your laptop has Java 21 installed along with your favorite IDE.

•••

One Does Not Simply Build Authentication: UI Components to the Rescue!
Ramona Schwering
Room 2206

Abstract:

Building authentication from scratch? Ain’t nobody got time for that! This hands-on workshop will explore how Auth0's pre-built UI components can help you implement robust authentication while maintaining testability and accessibility. We'll focus on practical implementation patterns instead of crafting authentication flows from scratch. Here's what we'll cover:

✅ Plug-and-play Auth0 UI components
✅ Customization tips for branding and UX
✅ Common pitfalls and how to avoid them

By the end, you’ll have a secure application with Auth0-powered authentication features that look great and keep your users (and security team) happy. Let’s make authentication easy, stylish, and safe—no dark magic required!

Prerequisites:

Prerequisites can be found in the workshop's README.md:
https://github.com/leichteckig/kcdc-sample/blob/main/README.md#prerequisiteds-for-the-workshop.

Please make sure to check them before joining the workshop. Thank you!

•••

Build Your Ultimate Dev Ecosystem: Code Hosting, CI/CD, Artifact Registry, and Dev Environments
Dewan Ahmed
Room 2210

Abstract:

Step into the ultimate developer experience with an open-source platform that brings code hosting, collaboration, CI/CD workflows, artifact management, and preconfigured development environments to your laptop using just Docker. This 180-minute workshop dives deep into how open-source tools empower developers to build, test, and deploy software efficiently, all while maintaining complete control over their development stack.

The session includes a hands-on technical demonstration of setting up Harness Open Source for local code hosting and managing CI/CD pipelines. From seamless team collaboration to artifact registry capabilities, attendees will gain practical knowledge on leveraging open-source tools as a self-contained powerhouse for software delivery. We’ll also explore preconfigured dev environments built on devcontainers that eliminate setup headaches, letting you focus on what matters most - coding.

By the end of this workshop, you’ll have learned to:
- Host and Collaborate on Code Locally: Manage repositories, collaborate with team members, and maintain version control—all on your laptop.
- Run CI/CD Pipelines Locally: Set up and execute streamlined workflows without relying on external services.
- Utilize Artifact Management: Efficiently store and reuse build artifacts within your projects.
- Work in Preconfigured Dev Environments: Boost productivity with ready-to-use development setups built on devcontainers tailored to your stack.

This workshop is designed for developers, DevOps engineers, and technical leads who want to explore open-source, self-hosted solutions for their development needs. Whether working on a personal project or managing enterprise-level pipelines, this session provides the tools and insights to build a fully-featured development ecosystem.

Prerequisites:

  • Attendees must have admin access to install software. List of software needed for workshop: VS Code, Git, Docker CLI/Engine, Colima, k3d.

  • Workshop tested on Colima 0.8.2, Docker CLI/Engine 28.3.3, Git 2.39.2, Visual Studio Code 1.102.3, and k3d 5.6.0.

  • Internet access required to pull Docker images from Docker Hub and clone GitHub repos. Disable or adjust VPN/firewall if blocking access to these services.

  • Update Docker insecure registries in Colima:

    1. Stop Colima (if running):

      colima stop

    2. Edit configuration:

      colima start --edit

    3. Under the docker: section, add:

      docker:
  insecure-registries:
    - "localhost:3000"
    - "0.0.0.0:3000"
    - "127.0.0.1:3000"
    - "host.docker.internal:3000"

    4. Restart Colima:

      colima start

    5. Verify settings:

      docker info

•••

Teamwork Games – Unlocking Safe, Innovative, and High-Performing Teams
JL Heather
Room 2211

Abstract:

Great teams don’t just happen—they’re built through trust, collaboration, and a shared sense of purpose. Teamwork Games is an interactive, hands-on workshop designed to help leaders, facilitators, and team members create psychologically safe, innovative, and highly productive teams using experiential learning.

Through engaging team-based games, simulations, and reflection exercises, participants will explore the foundations of psychological safety, creative problem-solving, and high-impact collaboration. Whether you're leading a new team, trying to strengthen an existing one, or looking for ways to improve cross-functional collaboration, this session will equip you with the tools and techniques to build better teams through play.

Expect a fast-paced, high-energy session packed with team-building activities, group challenges, and debrief discussions that turn insights into action.

Prerequisites:

No pre-requisites.

•••

Capture the Flag 101
Micah Silverman
Room 2214

Abstract:

Capture the Flag events are exciting and competitive. But, they can be scary to developers and security practitioners who have never participated in them.

In this session, I introduce CTFs, discuss their benefits to developers, and examine an easy and medium-difficulty CTF challenge in depth.

Together, we walk through the wiley attacker's thought process and how to pick up clues based on the programming language and protocols involved. We google, form theories and test against what little information is provided in the challenge.

You don't need any prior knowledge of a specific programming language. Rather, we focus on developing the skills needed to participate in a Capture the Flag event.

After an introduction to Capture the Flag events, we dig into two challenges. These are real challenges from past CTF events.

For each challenge, we follow a pattern of discovery:

1. Introduce the challenge
2. Review clues from the challenge text and challenge interface
3. Give participants time to take on the challenge
4. Pause and review progress and give a hint
5. Give participants more time to solve the challenge
6. Review the solution and lessons learned

Prerequisites:

Required:

  • Personal/work laptop

  • Register at: https://101.ctf-snyk.io/

  • Text editor of choice (VS Code or other IDE recommended)

  • Python 3 runtime

  • Node.js runtime

  • HTTP client (curl, postman, HTTPie)

Optional:

  • Burp Suite (community edition is fine)

  • Snyk account

  • Snyk cli

•••

Do you want to build a copilot? Star Wars edition!
Jim Bennett
Room 2215A

Abstract:

In this session you will build your first copilot in C# using the new Microsoft.Extensions.AI abstraction, and your choice of LLM from OpenAI, Azure AI Foundry, or Foundry Local.

We'll look at the fundamentals of a copilot, from chat history to system prompts, creating a simple copilot that imitates your favorite Star Wars character, such as Darth Vader, Yoda, Or Jar Jar Binks (hey, we don't judge).

Then we'll dive into Tools, RAG, and Agents, and see how they can be used to add more knowledge of the Star Wars universe, and more capabilities to your copilot chat.

By the end of this session, you will have a basic understanding of both the architecture of a typical copilot, as well as having built one of your own in C# with Microsoft.Extension.AI and Semantic Kernel.

This session is aimed at developers with a basic understanding of building and debugging C#, and you will need the relevant tooling installed, such as the latest .NET SDK, Visual Studio, Visual Studio Code with the C# extension, or JetBrains Rider.

Prerequisites:

Hardware/Software

- Your own laptop, with the ability to access public AI APIs such as OpenAI, or Azure AI Foundry (check your VPN firewall if you are using a corporate device)

- The .NET 9 SDK installed

- A C# compatible IDE, such as Visual Studio, VS Code, or Rider installed

- The latest version of Node installed

- Optional: Foundry Local installed, with the Phi-4 model downloaded and running. Once Foundry local is installed, run foundry model run phi-4-mini in your terminal/command prompt to install this model.

Knowledge

- Basic experience programming in C#

•••

Building a Web Component Library
Burton Smith
Room 2215B

Abstract:

Web components have been around for a long time (since HTML 5 became a thing), but there hasn’t been a lot of attention given to them until recently. Now, tech organizations worldwide are adopting them and finding tremendous efficiency in creating framework-agnostic reusable components to build their Design System component libraries and applications.

In this workshop, we will learn about the important concepts around authoring web components as well as the technologies used to create, test, and distribute web component libraries for others to enjoy.

Prerequisites:

Nodejs (LTS and up is preferred) - https://nodejs.org/

The starter project can be cloned from:

https://github.com/break-stuff/lit-starter-kit

Or it can be created executing the following command in your CLI:

npm init lit-starter-kit your-project-name

•••

Demystifying Generative AI
Heli Helskyaho and Mary Grygleski
Room 2215C

Abstract:

Everybody is talking about Generative AI and models that are better than anything else before. What are they really talking about?

In this hands-on lab, we will discuss about Generative AI in theory and we will try it in practice. After this HOL, you are able to understand what Generative AI is all about and how it can be used.

Hands-on lab will include:
* What is Generative AI?
* What is LLM?
* Interacting with LLM models
* Prompt engineering
* Vectors, embedding models and generating embeddings
* Vector Search with Oracle Database 23ai
* Understanding RAG (Retrieval Augmented Generation)

Prerequisites:

All exercises are conducted using Oracle LiveLab’s cloud-based sandboxes.
All you need is your laptop and an Oracle Account. The account is free and can be created here:
https://profile.oracle.com/myprofile/account/create-account.jspx

•••

Contact us.

staff@kcdc.info