Training catalog
Every course is delivered in real time by a senior practitioner. Browse the catalog below, filter by track, and click a course to see its full description, objectives, outcomes, and syllabus.
Every senior engineer eventually faces a whiteboard and a vague problem. Every production outage is a systems design lesson learned the hard way. This course builds the foundations of modern systems design from first principles: how data is stored, cached, partitioned, and replicated; how traffic is balanced and services are decomposed; and how to reason explicitly about the tradeoffs behind each choice.
Through guided exercises you’ll practice the skill the industry actually tests: breaking an ambiguous problem into components, choosing between real alternatives, and defending your decisions under questioning. This is the first half of a two-part series. Systems Design II takes these foundations into scale, operability, and production reality.
Knowing the building blocks is table stakes. The real test begins when traffic spikes, dependencies fail, and every architectural decision carries a cost. This second half of the systems design series takes you from components to production reality: event-driven architectures that decouple at scale, capacity planning with real math, and reliability engineering with SLIs, SLOs, and error budgets.
You'll dissect full-scale case studies of how systems like YouTube, WhatsApp, and Uber handle millions of users and inevitable failures, and practice defending architectural decisions in the toughest forums, from design reviews to executive scrutiny. Prerequisite: Systems Design I or equivalent experience.
Modern engineering teams are expected to design, provision, and operate infrastructure that is elastic, resilient, and cost-efficient. On AWS, that starts with knowing which services actually matter. This course gives engineers a practical, end-to-end command of the AWS platform: provisioning and securing compute, designing VPC networks that scale, choosing the right storage for each workload, and locking it all down with IAM done right.
Through guided labs on live AWS services, you’ll move from console clicking to architecting environments you'd trust in production. You'll also learn to spot the cost and security mistakes that silently compound in growing AWS footprints. First course in the Cloud Engineering track, followed by Infrastructure as Code with Terraform and Kubernetes in Production.
Click-ops doesn’t scale, doesn’t survive an audit, and doesn’t let you sleep at night. This course teaches the discipline of infrastructure as code with Terraform: writing declarative configurations, managing remote state safely across a team, and structuring modules and workspaces so infrastructure stays maintainable as environments multiply.
You'll work the full lifecycle, from first resource to team workflows with locking, drift detection, and module versioning, and leave writing Terraform you'd actually merge. Fits between AWS Cloud Engineering and Kubernetes in Production, or stands alone for teams standardizing on IaC.
Kubernetes is easy to demo and hard to operate. This course takes you from cluster concepts to production reality: deploying and scaling workloads, managing networking and ingress, provisioning EKS clusters, and wiring the CI/CD and observability your platform needs to survive contact with real traffic.
You’ll confront the questions that determine whether a Kubernetes platform thrives or becomes a burden (security, cost control, storage, and failure handling) with guided labs throughout. The capstone of the Cloud Engineering track; pairs naturally with CKA Certification Preparation for teams pursuing certification.
The Certified Kubernetes Administrator (CKA) exam, administered by the CNCF, is the industry benchmark for validating hands-on Kubernetes administration skills under real exam conditions: a live, terminal-based, time-boxed performance test. This course prepares you to pass it with confidence by building genuine operational fluency through hands-on practice.
You will work through every domain of the official CKA exam curriculum: cluster architecture and installation, workloads and scheduling, services and networking, storage, and troubleshooting, with hands-on labs that mirror the exam's task-based format. Emphasis is placed on speed and precision with kubectl, imperative commands, and kubeadm-based cluster operations, since the exam rewards efficient, correct execution over theoretical knowledge alone.
Beyond technical mastery, the course trains exam-taking strategy: time allocation across weighted domains, effective use of official documentation during the exam, and full-length timed practice exams that simulate real conditions. Graduates leave not only exam-ready but equipped with the diagnostic instincts of a working Kubernetes administrator.
Some processes must survive failure: an order that takes days to fulfill, an onboarding flow that waits on a human, an agent loop that runs for hours. Durable execution is the paradigm that makes this tractable. Your code runs as if failures don’t happen, because the platform remembers exactly where it was and resumes from there. Temporal is the leading open-source implementation of this idea, and this course teaches you to think in it.
You’ll write real workflows and activities, learn the constraints that make durability possible, and master the patterns the paradigm unlocks: durable timers, signals and queries, sagas with compensation, and versioning live workflows. You’ll finish knowing not just how Temporal works, but when durable execution is the right tool, and when a queue, a cron job, or a state machine in your database is enough.
Running Temporal yourself means operating a distributed system with strong opinions about state: four coordinated services, a persistence layer that must never lose a write, and visibility infrastructure your engineers will live in. This course is for infrastructure practitioners who need to take Temporal from Docker Compose on a laptop to a production cluster their company can bet on.
You’ll deploy Temporal on Kubernetes with the Helm chart, configure persistence and Elasticsearch visibility, set up namespaces and mTLS, practice upgrades and scaling, and learn to read the signals that tell you the cluster is healthy, or about to not be. Heavy on labs: you’ll break things on purpose and fix them.
Every production incident is a question: what happened, and why? Observability is the discipline of making your systems answerable. Not with more dashboards, but with the right signals, structured the right way. This course builds the foundations: what logs, metrics, and traces each tell you, when each one wins, and the habits that separate useful telemetry from expensive noise.
You’ll learn structured logging done right, metrics without the cardinality trap, and tracing basics including context propagation across services. Hands-on throughout: you’ll instrument a sample service and practice reading each signal the way you’d need to at 3 AM.
OpenTelemetry has won. It’s the vendor-neutral standard for generating telemetry, and every serious observability backend speaks OTLP. But knowing OpenTelemetry exists and running it well in production are different things. This course takes you from the specification to a working production setup: semantic conventions, instrumentation strategies, and the Collector as the centerpiece of your telemetry architecture.
You’ll instrument services with auto and manual instrumentation, build Collector pipelines with receivers, processors, and exporters, implement head and tail sampling to control costs, and plan a migration off legacy agents. Vendor-neutral throughout: what you build works against any OTLP-compatible backend.
Collecting telemetry is the easy part. The hard part is what happens between your services and your backend: filtering noise, routing by tenant, dropping cardinality before it bankrupts you, and deriving new signals from the ones you have. This course is about the pipes, and about the advanced techniques that turn raw telemetry into answers.
You’ll build pipelines with Vector and Redpanda Connect (Benthos), use Kafka as the durable backbone for telemetry at scale, and master derived signals: span metrics from traces, metrics from logs, and exemplars that connect the two. The throughline is cost: every technique here either saves money or makes expensive telemetry worth it.
In an era where large language models underpin everything from developer tooling to customer-facing products, understanding how they actually work is no longer optional for technical teams. It's foundational literacy. This course demystifies the transformer architecture, the training and inference pipeline, and the practical techniques that separate effective LLM usage from guesswork. You'll leave with a working mental model of what these systems can and cannot do, and why.
We build intuition from the ground up: how text becomes tokens, how tokens become vectors, and how attention lets models reason over context. We then move quickly into applied territory: prompting strategies, the tradeoffs between fine-tuning, retrieval-augmented generation, and prompting, and how to evaluate model outputs rigorously.
Hands-on labs run throughout the course: you'll practice prompting techniques live, build a retrieval-augmented prototype, and evaluate model outputs with structured methods, so the concepts land as skills you can use.
In the age of AI, systems design skills matter more than ever. Agentic systems represent the newest, fastest-moving frontier of that discipline. This course takes you from first principles to advanced practice so you can design agent systems that are reliable, observable, and scalable enough to handle real production workloads, not just demos. You'll learn to reason about the components that make agents work: planning loops, tool use, memory, and orchestration across multiple agents.
Throughout the program, you'll examine the tradeoffs behind every architectural decision: when to add a planning layer versus a simple ReAct loop, how much autonomy to grant an agent, and how to keep costs and latency under control as complexity grows. You'll finish able to design agentic systems with the same rigor and clarity you'd bring to any distributed system, and to communicate those design decisions convincingly to engineering and business stakeholders alike.
Most engineering hiring fails long before the offer stage: unstructured interviews, uncalibrated interviewers, and loops that reward polish over the capabilities the role actually needs. This course trains your engineers, interviewers, and hiring managers to run a hiring process that predicts on-the-job performance: designing structured loops where every stage owns a defined signal, writing interview questions anchored in real work, and evaluating candidates consistently against shared rubrics.
Grounded in what the research actually says about interview validity (structured beats unstructured, work samples beat brainteasers) and in the practical realities of competitive hiring: selling senior candidates on your team, moving fast without cutting corners, and making defensible hire/no-hire decisions as a group. Your team leaves with a loop design they can run next week and interviewers who know what good looks like.
Hiring an engineering manager or director is the highest-leverage hiring decision your organization makes. It's also the hardest to get right, because leadership capability doesn't show up in a coding exercise or a portfolio review. This course prepares hiring managers, interview panels, and executives to evaluate engineering leadership candidates with the same rigor you apply to technical hiring: defining what the role actually demands, probing judgment through realistic case studies, and checking references in ways that yield real signal.
You'll learn to see past "culture fit" gut feel and polished storytelling: testing how candidates design organizations, handle underperformance, make hiring decisions, and communicate hard tradeoffs to stakeholders. The program closes the loop with panel decision-making and onboarding, because even a great leadership hire fails without a deliberate first 90 days.
Fair, consistent performance management is one of the highest-leverage skills an engineering leader can develop. It's also one of the least formally taught. This course provides a rigorous, practical framework for setting goals, evaluating engineers fairly, and having the hard conversations that performance management inevitably requires, replacing ad hoc judgment with defensible, repeatable process.
The program covers the full performance management lifecycle: setting meaningful goals and OKRs, running calibration sessions that reduce bias, delivering feedback that actually changes behavior, and handling underperformance and promotions with equal rigor. Special attention is given to measuring engineering productivity responsibly, using frameworks like DORA metrics alongside thoughtful qualitative judgment.
Custom programs
We regularly design custom instructor-led programs for teams with specific goals. Tell us what you're solving for.