Private corporate batches delivered onsite across Bangalore, or live online in IST (UTC+5:30) — taught by a practitioner who runs Puppet 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 Puppet as an operating estate: the agent-server transaction traced end to end including certificate lifecycle, classification through site.pp, an external node classifier or node groups, Hiera hierarchy design and deterministic lookup, catalog compilation cost and PuppetDB queries. The code half is taught as engineering — roles and profiles, data separation, defined types, custom facts and types, with puppet-lint, rspec-puppet and the Puppet Development Kit wired into a merge gate. Every exercise runs against a live server and agents, including the failures: an expired certificate, a duplicate resource declaration, a Hiera value that resolves from the wrong layer, and a run that reverts someone's manual fix.
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 Puppet that means a trainer who has run it in production — Puppet for Bangalore infrastructure teams — the agent-server transaction, node classification, Hiera layering, r10k code deployment and PuppetDB — 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.
Onsite sessions run at your own office. Puppet engagements in Bangalore commonly land at Manyata Tech Park, along the Outer Ring Road between Bellandur and Marathahalli, in Whitefield, Electronic City or Bagmane Tech Park, one site per day so peak-hour travel does not consume lab time. You provide the room, a screen and network access; each attendee runs their own server and two agents in virtual machines or containers, because certificate, classification and code deployment exercises must not be performed against a production server. Where the brief is restructuring your own control repository we work on a branch under NDA. Sessions are scheduled in IST (UTC+5:30) and planned around change windows rather than through them. Invoicing is in INR from our Indian entity with GST, against a purchase order where procurement requires one, and travel within Bangalore is included.
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 Puppet batchPuppet works as a transaction between an agent and a server. The agent gathers facts about its machine with Facter and requests a catalog. The server determines which classes apply to that node through classification, compiles the manifests and Hiera data into a catalog — a directed graph of resources with dependencies resolved — and returns it. The agent then enforces that catalog locally and sends back a report of what it changed. Compilation happening before anything is touched is the defining property: conflicting resources, dependency cycles and undefined variables are caught at compile time rather than halfway through a run.
Trust between those two halves is established by certificates. The server runs a certificate authority, agents submit signing requests, and every subsequent catalog request is authenticated by that certificate. It is unglamorous and it is where a large share of real incidents originate, because certificates expire, hostnames change and an estate that has run for years eventually meets both.
The language is genuinely declarative. Resources have types, titles and attributes; classes group them; defined types instantiate a pattern repeatedly; and the roles-and-profiles pattern gives a codebase a shape that survives growth — a node has exactly one role, a role includes profiles, and profiles wrap component modules with organisational decisions. Data lives outside the code in Hiera, layered by environment, node group or fact, so one module serves every environment without conditionals scattered through the manifests. Around that sit the pieces that make an estate operable: PuppetDB storing catalogs, facts and reports and making them queryable; exported resources for cross-node coordination; r10k or Code Manager deploying environments from Git branches; the Puppet Development Kit with puppet-lint and rspec-puppet for testing; and Bolt for the imperative tasks that do not belong in a catalog at all.
The estates Puppet manages did not go away; the people who built them did. Configuration management is now largely a maintenance discipline, and maintenance of a declarative system with layered data, node classification and a certificate authority is genuinely harder than writing it was in the first place. Organisations discover this when the original team has moved on and a routine change produces an outcome nobody predicted.
Compliance made it worse and more valuable at the same time. An estate that continuously enforces state and reports corrective change is exactly what an auditor wants, so Puppet's report data has become evidence. But evidence only holds if classification is understood, if Hiera resolution is deterministic, and if nobody has been making manual changes that the next run silently reverts. Teams need people who can explain, precisely, why a node has the configuration it has.
The third driver is modernisation under constraint. Most large Puppet estates need the same set of improvements — data moved out of manifests into Hiera, code restructured into roles and profiles, modules tested before deployment, environments deployed from Git rather than by hand, and Bolt used for the orchestration work that was awkwardly forced into catalogs. Those changes have to be made on a running estate without a freeze, which is a different and scarcer skill than greenfield authoring, and it is what the market currently pays for.
One run, start to finish. Facter and fact collection, the catalog request, server-side compilation, catalog enforcement, and the report sent back — traced live with debug output so every later topic has a place to attach.
Topics: Facter, core facts, custom facts and external facts · The catalog request and what the server needs to answer it · Compilation: classification, manifests, Hiera and the resource graph · Catalog enforcement and resource ordering · Reports, corrective change and noop mode · Agent scheduling, run interval and splay · Reading debug output without fear
The operational area that causes the most incidents. The certificate authority, signing requests, autosigning policies, certificate lifetime and expiry, revocation and cleaning a node, plus renaming and re-enrolling hosts without breaking the estate.
Topics: The Puppet certificate authority and its files · Certificate signing requests and manual signing · Autosigning: basic, policy-based and its risks · Certificate expiry and planned renewal · Revocation, the CRL and cleaning a node · Renaming a host and re-enrolling correctly · Diagnosing a failed connection from certificate errors
How a node ends up with its configuration. site.pp and node definitions, external node classifiers, Puppet Enterprise node groups with rules and inheritance, environment assignment, and the discipline of being able to answer why a class applied.
Topics: site.pp, node blocks and matching order · External node classifiers and their contract · Node groups, rules and inheritance in Puppet Enterprise · Environment assignment and per-node overrides · Classification versus data: what belongs where · Explaining why a node received a class · Migrating from node blocks to rule-based classification
Writing code that survives growth. Resources, relationships and metaparameters; classes, parameters and defined types; conditionals, iteration and functions; then roles and profiles as the structure that stops a codebase collapsing, and the refactoring path from a manifest tree that has neither.
Topics: Resource types, titles, attributes and metaparameters · Relationships, ordering, notify and subscribe · Classes, parameters and defined resource types · Conditionals, iteration, functions and data types · Duplicate resource declarations and how to avoid them · Roles and profiles: one role per node, profiles wrapping modules · Refactoring an existing tree into roles and profiles incrementally
Getting data out of code. The Hiera hierarchy, layers and lookup order, automatic parameter lookup, merge behaviours, encrypted data with eyaml, and designing a hierarchy whose resolution can be explained rather than discovered by experiment.
Topics: hiera.yaml, layers and hierarchy design · Automatic parameter lookup and explicit lookup calls · First, unique, hash and deep merge behaviours · Interpolation with facts, trusted facts and variables · Encrypted data with eyaml and key management · puppet lookup --explain as the diagnostic tool · Migrating data out of manifests without breaking environments
Getting code onto the server and answers out of the estate. The control repository, Puppetfile and module pinning, r10k and Code Manager deploying Git branches as environments, then PuppetDB: facts, catalogs and reports, queries, exported resources and the collectors that consume them.
Topics: Control repository structure and the Puppetfile · Module sources: Forge, Git and internal modules with pinning · r10k and Code Manager deploying branches as environments · Environment isolation and testing a change on a branch · PuppetDB: what it stores and how to query it · Exported resources and resource collectors, used sparingly · Reporting on corrective change and drift
Making a live estate safe to change. The Puppet Development Kit, puppet-lint and metadata validation, rspec-puppet unit tests, acceptance testing on real machines, and extending Puppet with custom facts, functions and types or providers when no resource fits.
Topics: Puppet Development Kit: scaffolding, validate and test · puppet-lint rules and adopting them on legacy code · rspec-puppet: compiling catalogs in tests and asserting resources · Acceptance testing against real machines · Custom facts and custom functions · Custom types and providers and the resource abstraction layer · A CI merge gate for a control repository
Living with Puppet for years. Compilation performance and server scaling, run scheduling across thousands of nodes, triaging failed runs at fleet scale, Puppet Enterprise console and role-based access, Bolt for imperative tasks and plans, backup and upgrade, and assessing a migration honestly.
Topics: Catalog compilation cost, caching and server sizing · Run scheduling, splay and thundering herds · Triaging fleet-wide run failures from reports · Puppet Enterprise console, RBAC and node group delegation · Bolt tasks and plans for imperative work · Backup, disaster recovery and upgrade planning · Comparing Puppet with Ansible and assessing migration without wishful thinking
We rebuild the agenda around the tools you actually run.
Request a custom agendaTrace one agent run from fact collection through classification and compilation to enforcement and report, then change a fact and prove exactly what changes in the catalog.
Break agent trust with an expired and a mismatched certificate, recover both cleanly, then implement policy-based autosigning that rejects an unauthorised node.
Design a four-layer hierarchy with fact-based interpolation and merge behaviours, then prove every resolved value for three different nodes using lookup explain output.
Refactor a monolithic manifest set into roles and profiles incrementally, proving after each step that the compiled catalog is unchanged.
Set up a control repository with a Puppetfile, deploy a feature branch as an environment with r10k, test a node against it, and roll back cleanly.
Deliver classification, data, code structure, tests and PuppetDB reporting such that any engineer can explain why any node has its configuration — and prove it on three nodes.
Puppet in Bangalore concentrates where fleets are large, long-lived and audited. Telecom and networking R&D around Manyata Tech Park and the Outer Ring Road, storage and virtualisation product groups, and the infrastructure teams of banking and insurance GCCs all run Puppet estates that predate the current team, and their common characteristic is enforcement rather than provisioning: the machines exist, they must match policy continuously, and a report has to show that they did. That pushes the training towards the parts of Puppet that are actually load-bearing — how a catalog is compiled from classification plus facts, how Hiera layers resolve a value across environment, node group and fact, why a compile takes eleven seconds and what that costs across four thousand nodes, and how corrective change is reported to someone who will be asked about it in an audit.
The operational half is equally specific. Certificate authority and agent certificate lifecycle causes more Bangalore incidents than the language does, because an estate that was set up years ago eventually meets an expiry nobody diaried. Code deployment with r10k or Code Manager, environment branches mapped to Git, PuppetDB queries used to answer inventory questions, and exported resources used carefully rather than everywhere are the day-to-day skills. Hiring here reflects a mature market rather than a growing one: Puppet appears in senior infrastructure and platform roles, often alongside Ansible for orchestration and Terraform for provisioning, and the ask is usually to stabilise and modernise an existing estate — move data out of manifests into Hiera, restructure into roles and profiles, add module testing, and produce an honest assessment when someone proposes replacing the whole thing.
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
I took Terraform training with the tutor named Mithilesh. I requested to tailor the course curriculum for my needs. He did an excellent job of showing me how to write the Terraform script per the instructions provided.
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.
My experience with the AIOps training was positive. The course covered important topics in a structured way, and Rajesh Kumar explained the concepts patiently. I found the practical aspects particularly helpful because they made the technical content easier to understand.
I was looking to improve my understanding of AIOps, and this training helped me achieve that goal. Rajesh Kumar explained the subject in a structured and practical manner. The sessions on different AIOps concepts were informative.
| 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.