Private corporate batches, live online cohorts and 1-on-1 mentoring in one hierarchical inventory compiled into Kubernetes manifests, Terraform, scripts and docs — with secrets as references — taught by a practitioner who runs it in production.
20 years across DevOps, SRE and Security · 10,000+ engineers trained · Trained teams at JPMorgan Chase, Verizon, Nokia and the World Bank
Principal DevOps Engineer & Architect
Rajesh teaches Kapitan around the inventory rather than the templates — class hierarchy design, parameter merging and interpolation, and the target composition that keeps forty environments from becoming forty copies. Sessions work through every input type against real output: Jinja2 for scripts and docs, Jsonnet and kadet for Kubernetes manifests, and the helm input for wrapping upstream charts with inventory-driven values. Secrets are covered as refs with GPG, KMS and Vault backends including rotation, and the course closes on the part that decides adoption — validating compiled output against Kubernetes schemas, reviewing the compiled diff in CI, and wiring the rendered tree into an Argo CD or Flux reconciliation loop.
Twenty years across DevOps, SRE and Security, in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe and others. He has trained engineers at JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus — more than 10,000 people personally. He teaches what he runs, not what he reads.
You are booked with a named engineer, and that is who turns up. Marketplaces and larger providers rotate whoever is free, so the person who sold you the agenda is rarely the person teaching it.
The same trainer is available for the next engagement, which matters when a team builds on what it learned last time.
Your batch is assigned a named trainer before it starts, and that is who teaches it. See the full faculty.
Engagements are matched on the tool, not the calendar. For Kapitan that means a trainer who has run it in production — one hierarchical inventory compiled into Kubernetes manifests, Terraform, scripts and docs — with secrets as references — rather than whoever is free that week. You are told who is teaching before you commit, and that person is on the discovery call that shapes the agenda.
Where a batch is large enough to need a second trainer, the pairing is declared up front. The lead trainer stays accountable for the syllabus and the assessment either way.
Principal DevOps Engineer & Architect
Twenty years across DevOps, SRE and Security in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe, IBM/Emptoris, Ness, MindTree and Accenture. He has trained more than 10,000 engineers personally, at organisations including JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus. He teaches what he runs, not what he reads.
Teams of 8–30
Custom agenda, your timezone, onsite or online, NDA-friendly.
Request a quoteIndividual engineers
A private instructor and a curriculum built around your goal.
₹99,999Individuals who want peers
Scheduled batch, max 8 to 10 hours of live instruction.
₹34,999A private batch starts with a discovery call. We look at the stack you actually run — the CI system, the cloud, the constraints — and map the agenda onto it, so examples use your topology rather than a generic one.
Delivery is onsite at your premises, live online, or hybrid, scheduled around your release calendar rather than ours. Batches run 8 to 30 engineers.
Every attendee leaves with recordings, slides, lab repositories and a completion certificate. You receive an attendance and assessment report. Invoicing supports PO and GST.
Talk to us about a private Kapitan batchKapitan is an open-source configuration management tool for generating the files that describe an environment. Rather than templating one kind of output, it compiles a single hierarchical inventory into many: Kubernetes manifests, Terraform configuration, shell scripts, Dockerfiles, documentation and CI pipeline definitions, all rendered from the same set of parameters. The unit of work is a target — one environment, cluster or tenant — and running kapitan compile produces a fully rendered directory tree per target that is committed to the repository as a reviewable artefact.
The inventory is where the leverage is. Kapitan uses a class-and-target model: classes hold reusable parameter fragments, targets compose those classes, and values merge down the hierarchy with interpolation between them. A change to a shared class propagates to every target that inherits it, and the compiled diff shows exactly what that change did across all of them before anything is applied. On top of that inventory, Kapitan supports several input types — Jinja2 for plain templating, Jsonnet for structured data generation, kadet for defining manifests as Python objects, and a helm input that renders upstream charts with values drawn from the same inventory.
Secrets are handled by reference rather than by embedding. Kapitan refs point at a backend — GPG, Google KMS, AWS KMS, Azure Key Vault, HashiCorp Vault kv or transit, or base64 for non-secret cases — so the repository stores a tag such as a vault reference and the value is only revealed at apply time. Kapitan is a niche tool with a modest community; it suits organisations managing many similar-but-different environments where the sprawl of per-environment values files has become the actual problem.
Every platform team eventually hits the same wall: forty values files that are ninety per cent identical, and no way to see what a shared change does to all of them at once. Helm and Kustomize both address part of that, but both stay inside the Kubernetes manifest world, so the Terraform, the CI pipeline, the on-call runbook and the deployment script drift away from the manifests they describe.
Kapitan takes the other position — that the environment definition is data, and every artefact for that environment should be generated from it. That makes it a good fit for multi-tenant platforms, regulated estates that need a reviewable rendered diff before every change, and organisations running the same stack across many clusters, regions or customers.
It is also worth being clear about scale. Kapitan has a small user base compared with Helm or Kustomize, so hiring for it is rare and the ecosystem is thin. The reason to learn it is that you already use it, or that the config-as-data model solves a sprawl problem the mainstream tools have not solved for you. This training treats both cases directly, including an honest comparison against the alternatives and the conditions under which one of them is the better answer.
Why per-environment values files multiply and what that costs. Kapitan's compile model — inventory in, rendered tree out — and an honest comparison against Helm, Kustomize, Jsonnet with Tanka and plain templating, including the cases where one of those is clearly the better tool.
Topics: The multi-environment configuration sprawl problem · Kapitan's model: inventory, targets, inputs, compiled output · Kapitan compared with Helm, Kustomize and Tanka · Generating more than Kubernetes: Terraform, scripts, docs, pipelines · Community size, ecosystem maturity and adoption risk · Installation, the CLI surface and project bootstrap
The module that decides whether a Kapitan repository stays maintainable. How classes compose, how parameters merge down the hierarchy, how interpolation resolves, and how to design a class layout that absorbs a new region or tenant without a rewrite.
Topics: Repository layout: inventory, targets, classes, components, compiled · Target files and the classes they compose · Class inheritance and merge order · Parameter interpolation and cross-references · Common, environment, region and tenant class patterns · Inspecting resolved values with kapitan inventory and searchvar · Designing a hierarchy that scales past twenty targets · Anti-patterns: deep nesting, duplicated classes, target-only parameters
Kapitan's most immediately useful capability for teams that are not only doing Kubernetes. Rendering shell scripts, Dockerfiles, Terraform, README files and pipeline definitions from the same inventory, so the operational artefacts stop drifting from the configuration they describe.
Topics: The jinja2 input type and template context · Accessing inventory parameters inside templates · Filters, loops and conditionals in Kapitan templates · The copy and remove input types · Generating deployment scripts and runbooks per target · Generating Terraform variable files and backend configuration · Output paths, file modes and executable scripts · Keeping generated documentation truthful by generating it
Structured generation instead of string templating. Jsonnet's object model, functions and libraries for composing manifests, then kadet, where manifests are defined as Python objects with the inventory available as data — with a clear-eyed comparison of when each is the right choice.
Topics: Jsonnet fundamentals: objects, functions, imports, hidden fields · The jsonnet input type and inventory access · Reusable Jsonnet libraries and kube-libsonnet · kadet: BaseObj, inventory() and Python-defined manifests · Composing Deployments, Services, ConfigMaps and Ingress programmatically · Multi-document output and file naming · Choosing between jsonnet, kadet and jinja2 per component · Debugging generation errors
Kapitan does not replace the upstream chart ecosystem, it consumes it. Rendering third-party Helm charts through the helm input type with values assembled from the inventory, then fetching remote dependencies from git and HTTP so the repository declares exactly which versions it compiles.
Topics: The helm input type and chart rendering · Supplying chart values from inventory parameters · Pinning chart versions and reproducible renders · External dependencies: git, git submodules and HTTP sources · kapitan compile --fetch and dependency caching · Patching rendered chart output · Mixing helm-rendered and Kapitan-generated manifests in one target · Upgrade workflow for an upstream chart
How Kapitan keeps credentials out of the repository while keeping them in the workflow. The ref model and its backends, writing and referencing secrets, revealing at apply time, and the operational questions that matter more than the syntax — who can reveal, and how a key is rotated.
Topics: The ref model: tags, paths and the refs directory · Backends: gpg, gkms, awskms, azkms, vaultkv, vaulttransit, base64, plain · Creating and updating refs from the CLI · Referencing refs inside templates and manifests · kapitan refs --reveal and where revealing should happen · Access control: who can decrypt which refs · Key and secret rotation without a repository rewrite · Why base64 and plain are not encryption
Making compiled output trustworthy and then delivering it. Validating manifests against Kubernetes schemas, linting the inventory, treating the compiled diff as the pull-request review artefact, and handing the rendered tree to Argo CD or Flux for reconciliation.
Topics: kapitan validate against Kubernetes API schemas · kapitan lint and inventory hygiene checks · Committing compiled output, and the arguments for and against · Compiled diff as the pull-request review surface · CI pipeline: compile, validate, diff, gate · Reveal at deploy time versus reveal in CI · Argo CD and Flux consuming a compiled directory · Multi-cluster rollout ordering and blast-radius control
We rebuild the agenda around the tools you actually run.
Request a custom agendaBuild a class hierarchy covering dev, staging and production across two regions, then add a fourth environment and prove it required only a target file.
Render per-target deployment scripts, Terraform backend configuration and documentation from one inventory, and show all three change together on one commit.
Generate the same application stack twice, once with Jsonnet libraries and once with kadet Python objects, then judge which one your team should maintain.
Wrap two third-party Helm charts with the helm input type, drive their values from the inventory, pin the versions, then perform a version upgrade and review the compiled diff.
Encrypt credentials against a KMS or Vault backend, reference them from manifests, reveal them only at apply time, then rotate the key across every affected ref.
Ship a change through a full pipeline — compile, schema validation, compiled diff review, merge — and have Argo CD or Flux reconcile the rendered output across two clusters.
Billed yearly at ₹9,996
Max 8 to 10 hours of live instruction
Full program, private instructor
8–30 engineers · custom agenda · onsite or online · PO and GST invoicing
Refunds. If we cancel or postpone a cohort, you get a full refund within 15 days. There is no money-back guarantee otherwise.
Terms. Course material remains licensed to the attendee. Read the terms.
Your data. We don't share it with third parties. Privacy policy.
Certificate of completion
The trainer (Rajesh) provided very good sessions on SRE profession. Not only hands-on learning on the tools but also SRE mindset.
Very good training session. Well explained from the basics to the complex concepts. Also tried to cover practicals and demos within the 3 hour sessions. The learning content and videos are of a great deal of help.
Basics explanation was exemplary from Rajesh where he dealt with complicated topics to be simple. Great learning stuff personally for me.
Very detailed explanation and has lots of patience in attending the questionnaire. Thanks again for your wonderful sessions.
Good discussion, helped us to understand different tools in SRE.
Got good lab sessions which kept the new DevOps tool learnings to the point and it helped a lot in my career.
| What matters | YouTube + blogs | Generic online course | Freelance marketplace | DevOpsSchool |
|---|---|---|---|---|
| Named practitioner | No | Rarely | Varies per booking | Yes — same trainer each time |
| Production experience | Unknown | Unknown | Unverified | 20 years, named employers |
| Custom agenda | No | No | Sometimes | Built from your stack |
| Onsite delivery | No | No | Sometimes | Yes |
| Lab environment | None | Sandbox that expires | Varies | Your own cloud — skill goes with you |
| Assessment | None | Quiz | Rarely | Assignments + capstone per module |
| Per-attendee certificates | No | Sometimes | Rarely | Yes |
| Corporate invoicing | No | Limited | Varies | PO and GST |
| Post-training support | None | Forum, time-limited | None | Lifetime forum access |
Tell us the team, the stack and the timeline. You'll get a straight answer, not a sales sequence.
Talk to an advisorPrefer to call or email?
More ways to reach us on the contact page.