Private corporate batches, live online cohorts and 1-on-1 mentoring in object-pipeline automation across Windows, Linux and cloud control planes — 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 PowerShell around the object pipeline rather than command memorisation — Get-Member and Get-Command as the discovery loop, filtering and shaping with Where-Object, ForEach-Object, Select-Object and Group-Object, then advanced functions with parameter validation, pipeline binding and proper error records. Sessions go into the parts that decide whether automation is safe to run at scale: execution policy and signing, ShouldProcess and -WhatIf, remoting and delegated credentials, module authoring and versioning, and testing with Pester before a script touches production.
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 PowerShell that means a trainer who has run it in production — object-pipeline automation across Windows, Linux and cloud control planes — 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 PowerShell batchPowerShell is a command shell, scripting language and automation framework built on .NET. Its defining feature is that the pipeline carries objects rather than text: Get-Service returns service objects with typed properties, so filtering, sorting, grouping and exporting are property operations instead of string surgery. That single difference removes the parsing layer that dominates traditional shell scripting, and it is why PowerShell one-liners stay readable as they get more capable.
The language is built around a discoverable command model. Every command is a Verb-Noun cmdlet, Get-Command finds them, Get-Help documents them with examples, and Get-Member shows exactly what an object exposes — which means an engineer can work out an unfamiliar API from the console rather than from documentation. Beneath that, the full .NET type system is reachable: you can instantiate types, call static and instance members, handle events and load assemblies when no cmdlet covers what you need. Modules package all of this for distribution, and the PowerShell Gallery and internal repositories make it installable.
Since PowerShell 6 the runtime is cross-platform and open source, so it runs on Linux and macOS alongside Windows. In practice it is the automation layer for Windows Server, Active Directory, Exchange, Microsoft 365, Azure and Intune; the scripting surface inside many build and deployment systems; and increasingly a general-purpose tool for engineers who want structured output from their automation rather than text they have to re-parse.
Most enterprises are not homogeneous. They run Linux for the platform and Windows for identity, collaboration, file services, endpoint management and a long tail of line-of-business applications — and that Windows estate is administered through PowerShell whether or not anyone planned it that way. Active Directory, Exchange Online, Microsoft 365, Azure and Intune all expose their real capability through modules, and a large part of it exists in no portal at all.
At the same time the boundary that once separated Windows scripting from everything else has gone. PowerShell runs on Linux, has first-class modules for Azure and AWS, executes in containers and pipeline agents, and is a supported connection type in mainstream configuration management tooling. Teams that treated it as a Windows administrator's tool now find it in their CI jobs, their cloud governance automation and their compliance reporting.
What organisations struggle to find is engineers who write PowerShell as engineering rather than as recorded commands: functions with proper parameters, pipeline support, error handling, modules that are versioned and published, and code that has been tested before it touched ten thousand mailboxes.
What PowerShell is, which runtime you are actually using, and the language core. Windows PowerShell 5.1 versus cross-platform PowerShell 7 and why the distinction matters in an enterprise, hosts and consoles, then expressions, variables, types and flow control.
Topics: PowerShell environments — Windows PowerShell 5.1, PowerShell 7, and the hosts they run in · Expressions and variables · Types, casting and the type accelerators · Flow control — if, switch, foreach, while, do · Operators, comparison and the -eq family · Strings, here-strings and formatting
The skill that makes PowerShell learnable: finding capability from the console. Get-Help and its example and full views, Get-Command with wildcards and module filters, updatable help, and a deliberate look at the mistakes beginners make and what the resulting errors are telling you.
Topics: Get-Help — parameters, examples, full and online views · Discover stuff using help · Finding commands with Get-Command · Making mistakes and reading the resulting errors · Verb-Noun naming and approved verbs · Aliases and why scripts should not use them
The core idea of the language. Objects flowing between commands, inspecting them with Get-Member, and shaping results with the filtering and iteration cmdlets — plus how parameter binding actually decides which property maps to which parameter.
Topics: Pipelines and how objects flow · Members, Get-Member and object inspection · Where-Object for filtering · ForEach-Object for iteration · Select-Object, Sort-Object, Group-Object and Measure-Object · Pipeline parameter binding: ByValue and ByPropertyName · Formatting versus data — why Format-Table must be last
PowerShell's uniform view of hierarchical data. The provider model that makes the registry, certificate store, environment variables and file system all navigable with the same commands, item cmdlets, and the shortcuts that make interactive work fast.
Topics: Location, location, location — the provider and location model · PowerShell drives and the provider cmdlets · Item, child item and item property cmdlets · The registry, certificate and environment providers · Invoke-Item and launching associated handlers · Cutting corners: launching PowerShell in context from the file manager
Moving from typed commands to a personal toolset. Basic and advanced functions, parameters and validation attributes, then profiles — how they load, how they differ per host, and how a team keeps a shared environment consistent without a shared machine.
Topics: Functions: definition, parameters and return values · Advanced functions — CmdletBinding, parameter attributes and validation · Supporting the pipeline in your own functions: Begin, Process, End · SupportsShouldProcess, -WhatIf and -Confirm · Profiles and profile load order · Profiles and hosts — why your function is missing in the ISE or VS Code · Building a project-navigation function, end to end
Getting code to run safely on someone else's machine. Script files and scoping, execution policy and what it is and is not, signing, and the error model — the difference between terminating and non-terminating errors being the single most common source of automation that silently does nothing.
Topics: Scripts and execution policy · Scopes: global, script, local and dot-sourcing · Code signing and certificate-based trust · Terminating versus non-terminating errors · ErrorAction, ErrorVariable and $ErrorActionPreference · try, catch, finally and throw · Error records, exceptions and writing useful failures · Transcripts, verbose and debug streams
What to do when no cmdlet covers the task. Creating objects, referencing types, calling static and instance members, handling events, and loading assemblies — the escape hatch that makes PowerShell as capable as the framework underneath it.
Topics: Creating objects with New-Object and ::new() · Referencing types and type accelerators · Using static members · Using instance members · Handling events · More on events — registration, actions and cleanup · Loading assemblies · Add-Type and compiling inline code
PowerShell in a world of existing command-line tools. How native executables differ from cmdlets, capturing their output and exit codes properly, wrapping them as functions that emit objects, adding pipeline support, and customising the prompt so context is always visible.
Topics: PowerShell commands versus console applications · Using console applications in PowerShell — quoting, arguments and the stop-parsing operator · Exit codes, $LASTEXITCODE and $? · Capturing commands as PowerShell functions · Parsing native output into objects · Supporting pipeline operations in functions · Customising the PowerShell prompt · A source-control-aware prompt, built live
Packaging automation so it can be shared and versioned. Where modules come from, discovering and installing them, manual installation for disconnected environments, then authoring your own with a manifest, exported members, versioning and publication to an internal repository.
Topics: A toast to PowerShell modules — why they exist · Where you find PowerShell modules · Module discovery with Find-Module and the Gallery · Useful modules for infrastructure and development work · Manual module installation and offline environments · Authoring a module: psm1, psd1 manifests and exported members · Module versioning and side-by-side installs · Publishing to an internal repository · Testing with Pester
PowerShell as the scripting layer inside a delivery pipeline. The nature of a build, task-based build scripts with psake, packaging artefacts, parameterising configuration per environment, and running the whole thing from a CI server rather than a workstation.
Topics: The nature of the build — tasks, dependencies and idempotency · Installing and running a psake build script · Documenting a build script · Building projects and compiling artefacts · The package task: producing a versioned artefact · Configuring the build per environment · Running builds on a CI server · Automating bisection to find a breaking change · Conditional logic and scaling a build across projects
Running automation against everything rather than one machine. PowerShell remoting and session management, credential and delegation handling, then the cloud and directory modules that carry most enterprise automation, and what changes when the script runs on Linux or in a container.
Topics: PowerShell remoting — WinRM, SSH transport and Enter-PSSession · Invoke-Command, sessions and fan-out execution · Credentials, SecretManagement and avoiding plaintext secrets · Just Enough Administration and constrained endpoints · Azure, AWS and Microsoft 365 modules · Active Directory automation patterns · Desired State Configuration in outline · Running PowerShell on Linux and in containers · Scheduling: scheduled tasks, systemd timers and pipeline triggers
We rebuild the agenda around the tools you actually run.
Request a custom agendaAnswer five real infrastructure questions with a single object pipeline each — no temporary variables, no text parsing, no formatting until the last command.
Turn a working script into an advanced function with typed parameters, validation attributes, pipeline binding and -WhatIf support, then prove each behaviour.
Debug a script that reports success while every operation failed, then rebuild it with correct terminating-error handling, try/catch and useful error records.
Build a module with a manifest and exported members, add a Pester suite, version it, publish it to an internal repository and install it on a clean host.
Use remoting and sessions to run a governance check across a host group, handle partial failure, and aggregate the results into a single exportable object set.
Deliver a task-based build that compiles, tests, versions and packages an artefact, runs unattended on a CI agent, and reports failures usefully.
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
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.
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.
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.