Workshops and Tutorials

I do workshops focused on the Developer Tools and DevOps / InnerSource culture, including presenting them at the conferences and local events. You can hire me to deliver an internal workshop (see Consulting).

Some of my recent workshops:

Browse by tag:testingtestcontainerswiremockaiapici-cdcloud-development-environmentsconfiguration-managementdevcontainersjenkins+mockingconfiguration-as-codedeveloper-toolsdockerembeddedgithubinfrastructure-as-codeinnersourcekuberneteslocalstackopen-sourcepipelineproject-managementpulumiroadmapsspring

Project Management and Culture

• +Open roadmaps for your projects (workshop)
  Hands-on workshop on designing, building, and maintaining roadmaps for open-source communities and internal projects using GitHub Issues, GitHub Projects, and AI
  Tags:open-sourceroadmapsgithubproject-managementinnersourceai

  Open roadmaps for your projects

  

  Speaker Deck

  Roadmaps help communicate vision, align stakeholders, and coordinate contributions. But creating a roadmap is only half the challenge. Keeping it accurate, relevant, and sustainable is much harder!

  In this hands-on workshop, Oleg will share the experiences of public roadmaps in the projects he has contributed to: Jenkins, WireMock, Keptn, CDF, etc.\ He'll share the reasons and principles that have guided creation of open roadmaps, the challenges encountered, the techniques and technologies that could be used in your projects. We’ll talk about maintaining roadmaps, common mistakes and how to avoid them.

  We will use GitHub Projects and GitHub Issues to build practical roadmaps, organize initiatives, and communicate priorities. We will also explore how AI can help monitor roadmap consistency, identify stale initiatives, and detect discrepancies between plans and actual development activity.

  As a part of the workshop, we will do a two-hour hands-on exercise where participants create a roadmap for their own project or a sample project provided by the speaker.

  Workshop Structure

  I. Roadmap Fundamentals

  • Why roadmaps matter for open-source and internal projects
  • Defining audiences, priorities, and planning horizons
  • Roadmaps versus backlogs and delivery schedules
  • Common mistakes and lessons learned

  II. Building Roadmaps with GitHub

  • GitHub Issues as the source of truth
  • GitHub Projects: fields, views, filters, and automation
  • Public versus internal roadmaps
  • Managing expectations and avoiding unnecessary complexity

  III. Hands-on: Build Your Roadmap (2 hours)

  Participants can bring their own project or use a prepared sample project.

  1. Define roadmap goals, audience, and guiding principles
  2. Organize issues, initiatives, and priorities
  3. Create a GitHub Project with suitable roadmap views
  4. Communicate plans and manage expectations
  5. Handle changing priorities and stalled initiatives
  6. Review the roadmap and define maintenance practices

  IV. AI-Assisted Roadmap Maintenance

  • Detecting stale initiatives and inconsistent statuses
  • Identifying missing ownership, dependencies, and duplicate work
  • Comparing roadmap plans with GitHub activity
  • Using AI assistants and automation for consistency reviews
  • Human oversight and limitations of AI-generated recommendations

  V. Wrap-up

  • Roadmap reviews and feedback
  • Sustainable maintenance practices
  • Lessons learned and Q&A

  Duration

  4 hours, including 2 hours of hands-on exercises. Breaks are not included.

  Prerequisites

  • Basic familiarity with GitHub
  • GitHub account and laptop
  • Optionally, an existing project to use during the workshop
  • Optionally, access to an AI assistant

  No prior experience with GitHub Projects is required.

  Tags:open-sourceroadmapsgithubproject-managementinnersourceai

  Learn more Close

Containers for Developmwent and DevEx

• +API Integration testing for Spring Boot apps, with Testcontainers and WireMock (workshop)
  Hands-on workshop on testing a Spring Boot app with Testcontainers, Dev Services and WireMock.
  Tags:testingwiremocktestcontainersapiaispring

  API Integration testing for Spring Boot apps, with Testcontainers and WireMock

  

  GitHubSpeaker Deck

  Testcontainers have become one of the most popular tools for software integration testing. If you can put your system under test into a container, Docker compose cluster, or pod, you’re likely to use this. If your target isn’t ready, not containerizable, or just too heavy for testing as is, you can always use mock testing frameworks, e.g., WireMock or MockServer in the JVM ecosystem. Can you combine both approaches? Sure!

  In this talk, we will classify integration testing of Spring projects and discuss application areas for WireMock and Testcontainers, and discuss which tool to choose for each use-case. And why not both? We will discuss putting WireMock into Testcontainers, and getting the best from their features thanks to the new WireMock modules for Testcontainers. Last but not least, we will see how to put WireMock in front of the Testcontainers or your real system to do deeper tests or even chaos engineering.

  P.S: We will focus on the Java/Kotlin examples and Spring, but the same approaches can be used everywhere

  Chapters

  1. Getting Started and introductions
  2. Spring Dev Services
  3. Containers for Development
  4. Now with WireMock - API mocking in development and tests
  5. Let's add some AI? Using Spring AI and SLMs for test purposes

  Requirements

  Participants only need Docker Desktop or another Testcontainers-compatible container engine.

  Tags:testingwiremocktestcontainersapiaispring

  Learn more Close

• +Container Developer Environments. Virtualizing your IDEs for embedded projects (workshop)
  Hands-on workshop on building Dev Containers and Cloud Development Environments for a ROS2 robotics project.
  Tags:embeddeddevcontainerscloud-development-environmentstesting

  Container Developer Environments. Virtualizing your IDEs for embedded projects

  

  GitHubSpeaker Deck

  Embedded development and QA are entering a new era, enabled by Cloud Development Environments (CDEs) such as GitHub Codespaces or Devcontainers, which allow fully configured workspaces to run on laptops, Kubernetes clusters, or public clouds. Containers and VMs, often managed with tools like KubeVirt and QEMU and wrapped by frameworks like Testcontainers, enable scalable, hardware-aware test setups for HIL testing, firmware validation, and system modeling.

  In this workshop, we build a containerized developer environment for a robotics project using the open-source ROS2 stack (C++/Python, CMake, custom build tools, Gazebo, etc.), or another audience-nominated example. Step by step, you will learn to define and customize Dev Containers for your technology stack, adapt IDEs for embedded workflows, and package the full environment for sharing across teams and reuse in CI/CD pipelines.

  We also explore how to move these environments beyond the laptop and run them on cloud-based development platforms such as GitHub Codespaces. By the end of the session, participants will understand how to virtualize their IDEs, standardize developer onboarding, and create reusable development environments that connect local workstations, cloud platforms, and automated pipelines.

  Workshop Structure

  I. Getting started

  • Environment Setup

  II. Key sections

  1. Devcontainer Basics
  2. Using AI and agents in Devcontainers
  3. C/C++ tooling in a Devcontainer
  4. Custom images in a Devcontainer
  5. ROS and Gazebo in a Devcontainer
  6. Moving to a Cloud Developer Environment

  III. Optional parts

  The following parts can be optionally chosen by the audience if the time allows and in any order:

  • Using Devcontainers in CI
  • Integration Testing with Testcontainers
  • Using Nix in Devcontainers
  • Connecting hardware to a Devcontainer
  • Custom CDEs - building your own IDEs at scale

  Target duration

  4..8 hours

  Tags:embeddeddevcontainerscloud-development-environmentstesting

  Learn more Close

• +Introduction to Dev Containers (workshop)
  Hands-on introduction to reproducible developer environments with Dev Containers, including AI tools, CDEs and CI for your favorite stack.
  Tags:devcontainerscloud-development-environmentsdeveloper-toolsaici-cd

  Introduction to Dev Containers

  TL;DR: Works in your IDE? Now you can ship it to your team, your PM and your CI system!

  Setting up a development environment can be time-consuming and difficult to reproduce across a team. Dev Containers let you describe the base images, tools, dependencies, and editor configuration for a project as code, so developers can work in a consistent environment on their laptops or in the cloud. The same container configuration can also support automated workflows.

  In this hands-on workshop, we build and customize a Dev Container for a project using a technology stack selected by the audience. We explore how to package development tools, use AI assistants and agents, and share the resulting environment across a team. We then take the environment to the cloud with GitHub Codespaces and explore how to reuse it in CI.

  By the end of the session, participants will understand how to define a reproducible development environment, adapt it to their project's tooling, and use it across in local developer environment, cloud developer environments, and CI/CD pipelines.

  Possible technology stacks

  Go, Python, Java, C/C++, or .NET

  Workshop Structure

  I. Getting started

  • Environment Setup

  II. Key sections

  1. Dev Container basics:
  2. Dev Containers 101
  3. Define and run a development environment in a Dev Container
  4. Key features
  5. Demos for the selected tech stack(s)
  6. **AI and agents in Dev Containers:
  7. Using coding agents in a Dev Container,
  8. Model Context Protocol (MCP) integrations
  9. Using SLMs and Ollama in a Dev Container.
  10. Custom images:
  11. Using a custom image with the dependencies and tools needed for the selected stack.
  12. Multi-container systems with Docker Compose or Podman Compose
  13. Cloud development environments:
  14. Move the environment to the cloud using GitHub Codespaces as an example.
  15. Dev Containers in CI:
  16. Explore how to reuse the development environment configuration in CI/CD pipelines with GitHub Actions as an example

  III. Optional parts

  Depending on the audience and available time, we can also explore:

  • Integration testing with Testcontainers in a Dev Container
  • Using Nix in Dev Containers
  • Custom cloud development environments (CDEs): building your own IDEs at scale

  Tags:devcontainerscloud-development-environmentsdeveloper-toolsaici-cd

  Learn more Close

• +Introduction to Testcontainers and WireMock (workshop)
  Hands-on introduction to integration testing and API mocking with Testcontainers and WireMock for the tech stack of your choice.
  Tags:testingapimockingtestcontainerswiremock

  Introduction to Testcontainers and WireMock

  

  Speaker Deck

  Integration tests often depend on databases, APIs, and other services that are slow to set up, unreliable, expensive, or unavailable during development. Testcontainers helps run real dependencies in disposable containers, while WireMock lets us model HTTP APIs when a real service is impractical to use. When should we use each approach, and how can we combine them?

  This hands-on workshop introduces container-based integration testing and API mocking. Participants work with an example in the technology stack(s), selected for the audience. We build test environments with Testcontainers, configure WireMock to simulate API responses, and bring them together to test an application's interactions with external services.

  By the end of the session, participants will understand how to choose between real and mocked dependencies, create repeatable integration tests, and exercise both successful responses and failure scenarios without relying on a live API.

  Possible technology stacks

  Java (Spring or Quarkus), Kotlin, Golang, Python, C/C++

  Workshop Structure

  Getting started

  1. Discussion of the audience's use-cases
  2. Environment Setup
  3. Optional - Integration testing fundamentals

  Main parts

  1. Getting started with Testcontainers, in a Dev Container
  2. Introduction to the key features
  3. Testcontainers Modules
  4. Demo for a database project
  5. Demo for an AI project with Ollama and a local SLM
  6. API mocking with WireMock
  7. Model HTTP endpoints and configure responses
  8. Exercise successful responses, errors, and delays
  9. Verify requests sent by the application
  10. Combining Testcontainers and WireMock
  11. Run WireMock in a container as part of the test
  12. Test an application against real and mocked dependencies

  Optional parts parts

  The following parts can be selected by participants:

  • Testcontainers with Docker Compose and Podman Compose
  • Data modeling and mocking with Testcontainers, WireMock and data libraries
  • Using the technologies for CI/CD
  • For Spring and Quarkus frameworks, Dev Services

  Requirements

  Participants need a laptop with a Testcontainers-compatible container engine and the development tools for the selected stack.

  Tags:testingapimockingtestcontainerswiremock

  Learn more Close

• +Mocks as Code. Modeling services in configuration management flows (workshop)
  Hands-on workshop testing infrastructure code with Testcontainers, LocalStack, WireMock and Pulumi.
  Tags:testingapiinfrastructure-as-codeconfiguration-managementwiremocktestcontainerspulumilocalstack

  Mocks as Code. Modeling services in configuration management flows

  

  GitHubSessionizeSpeaker Deck

  When managing service configurations at scale, we often need to automate testing of these configurations. In software integration testing, we can use Testcontainers - a popular framework for Docker and other container engines. For public cloud environments, there is LocalStack. And for API service providers, we have WireMock. Can we use the same toolchain for configuration management? If you use modern Infrastructure-as-Code tools like Pulumi, yes!

  In this edition, we will use Java or Kotlin for EVERYTHING, from the application itself and all the way up to Infrastructure as Code definitions and tests.

  In this workshop, we will go through the following topics:

  1. Containerizing Spring app development
  2. Integration testing with Testcontainers and LocalStack
  3. Mocking APIs with WireMock
  4. Infrastructure as Code (IaC) with Pulumi and Pulumi for Java
  5. Testing IaC locally, with all tools above combined

  See the demo repository used in this workshop. It also contains all the links to the used tools and additional learning materials.

  Gradle®, Develocity®, Build Scan®, and the Gradlephant logo are registered trademarks of Gradle, Inc. "Gradle" means "Gradle Build Tool" and does not reference Gradle, Inc. and/or its subsidiaries.

  Tags:testingapiinfrastructure-as-codeconfiguration-managementwiremocktestcontainerspulumilocalstack

  Learn more Close

• +Mocks as code: Modeling AWS service providers with Testcontainers, WireMock and Localstack (workshop)
  Combining LocalStack, WireMock and Testcontainers in a Dev Container to test cloud-based services and deployments.
  Tags:testingmockingtestcontainerswiremockconfiguration-management

  Mocks as code: Modeling AWS service providers with Testcontainers, WireMock and Localstack

  

  Speaker Deck

  When managing services at scale, you need automated testing while mocking (or modeling) the parts provided by public clouds, as well as testing entire deployment processes. This session demonstrates how to combine Localstack (for AWS integration testing), WireMock (for service mocking), and Testcontainers, a popular framework for Docker and other container engines, for comprehensive integration testing - all running in a Dev Container on your local machine.

  Using Pulumi and Java as examples, you'll see live coding that demonstrates how these tools work together, with the approach applicable to any tech stack. Expect a hands-on workshop format with minimal tool requirements, showcasing developer experience for modern, containerized developer environments and practical techniques you can apply immediately to your own services.

  Tags:testingmockingtestcontainerswiremockconfiguration-management

  Learn more Close

Jenkins

• +Developing Jenkins Pipelines (workshop)
  Hands-on development and testing of Jenkins Pipelines and shared libraries.
  Tags:jenkinspipelinetestingci-cd

  Developing Jenkins Pipelines

  

  Speaker Deck

  Developing a Jenkins Pipeline should not mean pushing every change to a shared server and waiting for a build to find the next mistake. In this hands-on workshop, we explore developer tools and practices for writing, reviewing, and testing Pipelines with a faster feedback loop.

  Participants work with Jenkinsfiles and shared Pipeline libraries, extract reusable automation, and explore ways to validate and test changes locally. We compare testing approaches, from unit testing Pipeline code and mocking Jenkins steps to integration testing against a containerized Jenkins instance with Testcontainers. Along the way, we discuss maintainability, versioning, and common pitfalls when sharing Pipeline code across projects.

  Workshop chapters

  1. Pipeline fundamentals and practices: Develop Jenkinsfiles and discuss readability, maintainability, and common pitfalls.
  2. Pipeline developer tools: Use local editing and validation workflows to shorten the feedback loop before committing changes.
  3. Shared Pipeline libraries: Managing Jenkins pipelines at scale.
  4. Extract reusable automation, organize and version libraries, and use them across projects.
  5. Unit testing: Explore testing frameworks for Pipeline code, including mocking Jenkins steps and testing shared library behavior.
  6. Integration testing: Run and test Pipelines against a containerized Jenkins instance using Testcontainers, and compare integration and unit tests.

  Tags:jenkinspipelinetestingci-cd

  Learn more Close

• +Docker and Jenkins [as Code] (workshop)
  Hands-on Jenkins configuration management with Docker, Kubernetes, Configuration as Code, and Groovy hooks.
  Tags:jenkinsdockerkubernetesconfiguration-as-codeci-cd

  Docker and Jenkins [as Code]

  

  GitHubSpeaker Deck

  How can you make a Jenkins installation reproducible, portable, and easier to maintain? In this hands-on workshop, we manage Jenkins configuration as code and run Jenkins with Docker and Kubernetes. We explore controller and agent images, build a custom Jenkins image, and manage its plugins and configuration alongside the code.

  Participants use Jenkins Configuration as Code (JCasC) to define settings in YAML and Groovy hooks to customize initialization where needed. We discuss how the two approaches work together, how to handle configuration changes, and how container images and Kubernetes agents fit into a repeatable Jenkins setup.

  The workshop can be adapted to a duration of 2 to 8 hours, from an introduction to a deeper, hands-on exploration.

  Workshop chapters

  1. Jenkins configuration as code: Explore the components of a Jenkins installation and the benefits of storing configuration alongside code.
  2. Jenkins with Docker: Run controller and agent images, build a custom Jenkins image, and manage its plugins.
  3. Jenkins Configuration as Code: Define and apply Jenkins settings with JCasC and YAML, and manage configuration changes.
  4. Groovy hooks: Customize Jenkins initialization with Groovy and combine hooks with JCasC where additional flexibility is needed.
  5. Jenkins on Kubernetes: Explore containerized Jenkins deployments and Kubernetes agents as part of a repeatable setup.

  The depth and hands-on exercises in each chapter can be adapted to the available time.

  Tags:jenkinsdockerkubernetesconfiguration-as-codeci-cd

  Learn more Close