Workshops

Hands-on, practitioner-led workshops built from real delivery experience. Not slideware. Your team leaves with skills they can use the next day.

nix 
{
  description = "dev environment";

  inputs.nixpkgs.url = "github:NixOS/nixpkgs";

  outputs = { nixpkgs, ... }:
    let pkgs = nixpkgs.legacyPackages.x86_64-linux;
    in {
      devShells.default = pkgs.mkShell {
        buildInputs = [
          pkgs.nodejs_22
          pkgs.postgresql
          pkgs.redis
        ];
      };
    };
}

Infrastructure

Nix

Reproducible, declarative infrastructure from first principles. Covers the Nix language, flakes, dev shells, CI pipelines, and deployment. Your team leaves able to build systems that are the same everywhere, every time.

For teams adopting Nix, or wanting to, who need a fast, correct start.

Book this workshop
nix + k8s 
{ config, lib, ... }:

let cfg = config.catallaxy.cluster;
in {
  options.catallaxy.cluster = {
    enable = lib.mkEnableOption "cluster";
    namespace = lib.mkOption {
      type = lib.types.str;
      default = "production";
    };
  };

  config = lib.mkIf cfg.enable {
    kubernetes.resources.namespace = {};
  };
}

Platform Engineering

Catallaxy: Taming Kubernetes with Nix

A deep dive into managing Kubernetes declaratively with NixOS modules. Covers the Catallaxy platform, reproducible cluster configuration, and building infrastructure where good defaults emerge from sound rules rather than manual intervention.

For platform teams running Kubernetes who want deterministic, auditable deployments.

Book this workshop
haskell 
data Expr
  = Lit Double
  | Add Expr Expr
  | Mul Expr Expr

eval :: Expr -> Double
eval (Lit n)   = n
eval (Add a b) = eval a + eval b
eval (Mul a b) = eval a * eval b

simplify :: Expr -> Expr
simplify (Add a (Lit 0)) = simplify a
simplify (Mul a (Lit 1)) = simplify a
simplify other            = other

Software Engineering

Functional Programming

Practical functional programming tailored to your team's language: Haskell, Scala, or functional-style TypeScript. Algebraic data types, composition, error handling without exceptions, and patterns that eliminate whole categories of bugs.

Tailored to your team's stack and experience level. From first steps to advanced patterns.

Book this workshop
haskell 
prop_reverseInvolution :: [Int] -> Bool
prop_reverseInvolution xs =
  reverse (reverse xs) == xs

prop_sortIdempotent :: [Int] -> Bool
prop_sortIdempotent xs =
  sort (sort xs) == sort xs

prop_roundtrip :: User -> Bool
prop_roundtrip user =
  decode (encode user) == Right user

Quality & Correctness

E2E Testing & Property-Based QA

Move beyond example-based tests. Property-based testing, generative inputs, shrinking, and end-to-end strategies that find the bugs your test suite misses. Covers frameworks across languages and integration into CI.

For teams who want fewer bugs by making bugs impossible, not just uncaught.

Book this workshop

How workshops work

1

Scope the session

A short call to understand your stack, your gaps, and your goals. Every workshop is tailored.

2

Build real things

Your engineers work through hands-on exercises drawn from real production scenarios, not toy examples.

3

Leave ready

Your team walks out with working code, reference material, and the confidence to apply what they learned immediately.

Ready to level up your team?

Workshops are scoped to your team's size and goals. Let's talk about what would move the needle for your team.