Private corporate batches, live online cohorts and 1-on-1 mentoring in the language the cloud-native stack is written in — CLIs, controllers and services — 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 Go for infrastructure work rather than as a general programming course — errors as values and wrapping with %w, interfaces satisfied implicitly, goroutines and channels with the race detector running, and context propagation for cancellation and deadlines across a call tree. Sessions build real artefacts: a cobra-based CLI with configuration and signal handling, an HTTP service with graceful shutdown and instrumentation, and a Kubernetes controller written with client-go and controller-runtime against a live cluster rather than a diagram.
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 Golang that means a trainer who has run it in production — the language the cloud-native stack is written in — CLIs, controllers and services — 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 Golang batchGo — usually written Golang when you need to search for it — is a compiled, statically typed language from Google designed for building networked services and command-line tools. It compiles to a single static binary with no runtime dependency, cross-compiles for any supported platform from one machine, and starts in milliseconds. Those three properties are why it displaced C++, Java and Python for infrastructure software: a Go tool ships as one file that runs anywhere, which is exactly what an operator, an agent or a CLI needs.
The language is deliberately small. There is no inheritance, no exception mechanism and, until recently, no generics; errors are ordinary return values that must be handled explicitly, interfaces are satisfied implicitly rather than declared, and composition replaces class hierarchies. Concurrency is built in rather than bolted on — goroutines are cheap enough to spawn thousands of, channels and select coordinate them, and the context package carries cancellation and deadlines through an entire call tree. The toolchain is part of the language: go build, go test, go fmt, go vet, the race detector and pprof ship with the compiler and need no configuration.
The practical case for learning Go is that the cloud-native stack is written in it. Kubernetes, Docker, containerd, etcd, Prometheus, Terraform, Vault, Consul, Helm, Istio and the CNCF landscape around them are Go programs, so reading their source, extending them with plugins, building controllers against their APIs and contributing fixes all require the language.
Platform teams have stopped being able to buy their way out of tooling. Every organisation past a certain size ends up writing its own CLI, its own admission policy, its own operator for an internal service, its own exporter, its own migration controller — and all of those are written in Go, because that is what the APIs they target are written in.
The hiring signal follows. Platform engineering, SRE and cloud-native infrastructure roles increasingly ask for Go specifically rather than for general programming ability, and the reason is concrete: a Kubernetes controller is a Go program using client-go and controller-runtime, a Terraform provider is a Go plugin, a Prometheus exporter is a Go HTTP handler. Python will not get you into that code.
There is a second, quieter driver. Distribution matters. A Python tool needs an interpreter, a virtual environment and a dependency resolution step on every machine that runs it; a Go tool is a single static binary you copy. For anything that has to run on build agents, in scratch containers, on customer infrastructure or across a heterogeneous fleet, that difference decides adoption.
Why Go looks the way it does and how its toolchain works. Installation and version management, modules and go.mod, project layout, the build and run cycle, gofmt and go vet as non-negotiable defaults — then the language core: declarations, types, zero values, control flow and functions.
Topics: Why Go for infrastructure tooling, and where it is the wrong choice · The toolchain: go build, run, test, fmt, vet and install · Modules, go.mod, go.sum and dependency versioning · Project layout and package naming that ages well · Declarations, types and zero values · Control flow — if, for, switch and the absence of while · Functions, multiple returns and named results · defer and its evaluation rules
Go's composite types and the behaviour that surprises people arriving from other languages. Arrays versus slices and what append actually does, slice aliasing, maps and their iteration order, structs and embedding, pointers and value semantics, and where escape analysis puts your data.
Topics: Arrays, slices, capacity and what append really does · Slice aliasing and the bugs it causes · Maps, key types and non-deterministic iteration order · Structs, embedding and struct tags · Pointers, value versus pointer receivers · Escape analysis, stack and heap in outline · Strings, runes, bytes and encoding · Generics: type parameters and when they earn their keep
The two ideas that most shape idiomatic Go. Errors as ordinary values — construction, wrapping, sentinel errors, custom types and inspection — and interfaces satisfied implicitly, which changes where you define them and how you test against them.
Topics: Errors as values: construction, returning and handling · Wrapping with %w, errors.Is and errors.As · Sentinel errors and custom error types · panic, recover and the narrow cases they are for · Interfaces and implicit satisfaction · Accept interfaces, return structs — and why · Composition over inheritance · Package boundaries, exported identifiers and API design · Dependency injection without a framework
Go's headline feature and its sharpest edge. Goroutines and the scheduler, channels and select, synchronisation primitives, worker pools and pipelines, then the context package for cancellation and deadlines — with the race detector running throughout, because concurrent code that has not been raced is unverified.
Topics: Goroutines and the scheduler model · Channels: buffered, unbuffered, closing and ranging · select, timeouts and default cases · sync.WaitGroup, Mutex, RWMutex and sync.Once · Worker pools, fan-out and fan-in pipelines · Goroutine leaks and how to spot them · context: cancellation, deadlines and values · Propagating context through HTTP clients and servers · The race detector and go test -race · errgroup for coordinated failure
How much you get without a single dependency. Files and paths, process execution and signals, the io interfaces that everything composes around, encoding for JSON and YAML, time and tickers, and net/http as both client and server — which is more capable than most people assume.
Topics: os and io/fs — files, paths, permissions and directory walking · io.Reader and io.Writer as the universal interface · os/exec — running commands, streaming output, exit codes and timeouts · os/signal and graceful shutdown · encoding/json and struct tags; working with YAML · time, timers, tickers and monotonic clocks · net/http clients: timeouts, transports, retries and connection reuse · net/http servers: handlers, middleware and routing · log/slog for structured logging
Turning Go code into software other engineers install and run. Flags and subcommands with cobra, layered configuration with viper, structured logging and verbosity, signal handling and graceful shutdown, health and readiness endpoints, and Prometheus instrumentation.
Topics: flag versus cobra: choosing a CLI structure · Subcommands, flags, arguments and usage output · Configuration precedence with viper — flags, environment, file, defaults · Exit codes and machine-readable output modes · Structured logging and log levels · Signals, graceful shutdown and draining in-flight work · Health, readiness and liveness endpoints · Prometheus metrics and the client_golang library · Versioning a binary with ldflags
Go's built-in quality tooling, which needs no third-party framework. Table-driven tests, subtests and fixtures, fakes and interfaces instead of mocking libraries, httptest for service tests, benchmarks, and pprof for finding where the time and allocations actually go.
Topics: Table-driven tests and subtests · Test fixtures, golden files and testdata · Fakes and interfaces instead of mocking frameworks · httptest for handler and client tests · Coverage and what it is and is not evidence of · Benchmarks and benchstat comparisons · CPU, memory and goroutine profiling with pprof · Escape analysis and reducing allocations · Fuzzing in outline · Integration tests against containers
The reason most infrastructure engineers learn Go. Talking to the Kubernetes API with client-go, informers and the reconciliation model, then building a controller with controller-runtime and kubebuilder against a real cluster — plus how the resulting binary gets built, containerised and released.
Topics: The Kubernetes API from Go: client-go, clientsets and dynamic clients · Informers, listers and the watch model · The reconciliation loop and level-triggered design · Custom resource definitions and generated types · Building a controller with controller-runtime and kubebuilder · Admission webhooks in outline · Cross-compilation and CGO_ENABLED=0 static builds · Minimal container images: distroless and scratch · Release automation with goreleaser and reproducible builds · Supply chain basics: module checksums, vendoring and SBOMs
We rebuild the agenda around the tools you actually run.
Request a custom agendaBuild a cobra-based tool with subcommands, layered configuration, structured logging, a --dry-run mode and correct exit codes, then cross-compile it for three platforms.
Write a fleet scanner with a worker pool, per-task timeouts and context cancellation, then run it under the race detector until it is clean.
Build a service with middleware, request timeouts, health endpoints and Prometheus metrics, then prove it drains in-flight requests on SIGTERM.
Take a working but slow program, profile it with pprof, identify the real hotspot, reduce allocations, and prove the improvement with benchstat.
Use client-go to list and watch a resource type on a live cluster, handle resync and errors, and act on changes idempotently.
Scaffold a CRD and controller with kubebuilder, implement a level-triggered reconcile loop with status conditions, containerise it and deploy it to a cluster.
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
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.
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.
| 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.