Private corporate batches, live online cohorts and 1-on-1 mentoring in distributed search and analytics — inverted indexes, mapping, the Query DSL and aggregations at scale — 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 Elasticsearch from the inverted index outward — how analysers, tokenizers and filters decide what is searchable, why a mapping is a one-way decision, and what BM25 relevance actually scores. Sessions work the whole path in the API rather than in a UI: index and document CRUD, bulk operations, query versus filter context, full-text and term-level queries, boolean compound queries and boosting, then metric, bucketing and multi-level nested aggregations. The operational half — shard sizing, cluster health and allocation, index lifecycle management, snapshot and restore, and reindexing without downtime — is covered against a running multi-node cluster.
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 Elasticsearch that means a trainer who has run it in production — distributed search and analytics — inverted indexes, mapping, the Query DSL and aggregations at scale — 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 Elasticsearch batchElasticsearch is a distributed search and analytics engine built on Apache Lucene. Documents are indexed as JSON, and behind each field Lucene maintains an inverted index — a map from every analysed term to the documents that contain it. That structure is why a full-text query across hundreds of millions of documents returns in milliseconds, and it is also why the analysis chain that produces those terms is the most consequential design decision in any Elasticsearch deployment.
An index is divided into shards, each shard is an independent Lucene index, and shards are distributed and replicated across the nodes of a cluster. That gives horizontal scale and availability, but it also fixes the constraints engineers have to work within: primary shard count is set at creation, cluster state and shard allocation drive most operational incidents, and shard sizing is the difference between a fast cluster and one spending its life on garbage collection.
Queries are expressed in the JSON Query DSL. The critical distinction is between query context, which scores documents by relevance using BM25, and filter context, which answers a yes-or-no question and is cacheable. On top of search sits the aggregation framework — metric aggregations that compute, bucket aggregations that group, and nested combinations of both — which turns Elasticsearch into an analytics engine over the same data it searches. Elasticsearch is the storage and query layer of the Elastic Stack; Logstash and Beats feed it, and Kibana renders it.
Search is no longer a feature bolted onto an application; it is how people expect to interact with any large body of data. Product catalogues, document stores, log platforms, security data lakes and observability back ends all end up needing the same capability — full-text relevance, structured filtering and aggregation over the same corpus — and Elasticsearch is the engine most organisations reach for.
That breadth is exactly why the skill is in demand and why superficial familiarity is not enough. The same cluster serves an application team that cares about relevance tuning and an operations team that cares about ingest rate and shard count, and both sets of decisions land on the same mapping. Teams that treat Elasticsearch as a document database discover the cost late: mappings that cannot be changed without reindexing, shards sized by accident, and queries that scored badly because the analyser was never considered.
The operational half is where organisations hire. Understanding cluster state, allocation, index lifecycle management, snapshot and restore, and how to size shards for a stated retention window is what separates an Elasticsearch deployment that grows quietly from one that produces an incident every quarter.
The theory that makes everything afterwards obvious rather than magical. A brief history of search, what a search engine has to do that a database does not, the inverted index as a data structure, and Lucene as the open-source library underneath. Then where Elasticsearch fits, and the workloads for which it is the wrong store.
Topics: A brief history of search and what problem it solves · How search works: tokenisation, terms and postings · The inverted index as a data structure · Lucene: segments, immutability and merging · Introducing Elasticsearch: what it adds over Lucene · Elasticsearch compared with relational databases and document stores · The Elastic Stack: Elasticsearch, Logstash, Beats, Kibana · Where Elasticsearch is the wrong choice
A cluster you can see inside. Installation from archive, package and container, the configuration files that matter, node roles and discovery, then the diagnostic surface: cluster health, the cat APIs, node stats, and what green, yellow and red actually mean.
Topics: Installing and setting up Elasticsearch: archive, package, Docker · elasticsearch.yml, jvm.options and heap sizing · Node roles: master, data, ingest, coordinating · Cluster formation, discovery and quorum · Basic concepts: cluster, node, index, document, shard, replica · Monitoring the health of the cluster: _cluster/health and its fields · The cat APIs for human-readable diagnostics · Introducing cURL and the REST API conventions · Reading node stats and identifying pressure
The document lifecycle in full. Creating indices with settings, adding documents with and without explicit IDs, retrieving whole and partial documents with source filtering, full and partial updates, the versioning and optimistic-concurrency model, deletion, and bulk operations including loading a large JSON file.
Topics: Creating indices: settings, shard and replica counts · Adding documents to an index; auto-generated vs explicit IDs · Retrieving whole and partial documents; _source filtering · Updating whole documents and partial updates via _update · Scripted updates and upserts · Versioning, sequence numbers and optimistic concurrency control · Deleting documents and deleting indices · Delete-by-query and update-by-query · Performing bulk operations on documents · Bulk indexing from a JSON file and handling partial failures · Index aliases and why you should always query one
The two decisions you cannot easily undo. Mapping: dynamic versus explicit, field data types, text versus keyword and the multi-field pattern, dynamic templates, and which changes force a reindex. Analysis: the analyser chain of character filters, tokenizer and token filters, the built-in analysers, custom analysers, and testing everything with _analyze.
Topics: Dynamic mapping and its dangers · Explicit mappings and field data types · text vs keyword, and the multi-field pattern · Numeric, date, boolean, object and nested types · Dynamic templates and index templates · Which mapping changes require a reindex · The analysis chain: character filters, tokenizer, token filters · Built-in analysers: standard, simple, whitespace, keyword, language analysers · Custom analysers: stemming, stopwords, synonyms, ASCII folding · Testing with the _analyze API · search_analyzer vs analyzer, and why they can differ · Normalizers for keyword fields
The query language in depth. URI search versus request-body search, the crucial split between query context and filter context, full-text queries, term-level queries, and how relevance is actually computed. Then compound queries with bool, boosting, and the explain API for when a result ranks somewhere surprising.
Topics: Search using query parameters vs the request body · Query context and filter context: scoring versus filtering, and caching · Setting up realistic data for query practice · Source filtering, pagination, sorting and search_after · Full-text queries: match, match_phrase, multi_match, query_string · Relevance: TF/IDF and the BM25 algorithm · Queries with common terms, fuzziness and minimum_should_match · Term-level queries: term, terms, range, exists, prefix, wildcard · Boolean compound queries: must, should, filter, must_not · The boost parameter and function_score · Searching in the filter context for structured criteria · The _explain and _validate APIs · Highlighting and suggesters
Elasticsearch as an analytics engine. The aggregation families and how they compose, metric aggregations for computation, the cardinality aggregation and its approximation trade-off, bucketing aggregations for grouping, multi-level nesting, and the filter and filters aggregations for slicing one result set several ways at once.
Topics: Types of aggregation: metric, bucket, pipeline, matrix · Implementing metric aggregations: avg, sum, min, max, stats, extended_stats · Percentiles and percentile ranks · The cardinality aggregation and HyperLogLog approximation · Bucketing aggregations: terms, range, date_histogram, histogram · Terms aggregation accuracy, size and doc_count_error · Multi-level nested aggregations · The filter and filters bucketing aggregations · Aggregations on nested and parent-child documents · Pipeline aggregations: derivative, moving_avg, bucket_selector · Combining queries and aggregations in one request · Aggregation performance and memory pressure
How the distributed part behaves, and how document design interacts with it. Shard allocation and routing, what happens on a search request across shards, the coordinating node's role, replicas and read scaling — then modelling choices: flat documents, nested types, join fields, denormalisation, and the time-series index pattern.
Topics: Shards, replicas and how a search is executed across them · Routing: default hashing and custom routing keys · The coordinating node, query phase and fetch phase · Shard sizing: rules of thumb and how to measure your own · Allocation, rebalancing and allocation awareness · Diagnosing unassigned shards with _cluster/allocation/explain · Data modelling: denormalisation versus nested versus join fields · Nested documents and their query cost · Time-based indices, data streams and rollover · Index templates and component templates · Choosing a primary shard count you will not regret
Keeping it healthy over time. Index lifecycle management across hot, warm, cold and delete phases, snapshot and restore to object storage, reindexing without downtime, rolling upgrades, backup strategy, security basics, and the performance tuning levers for both indexing and search.
Topics: Index lifecycle management: hot, warm, cold, frozen, delete · Rollover, shrink and force-merge · Snapshot and restore: repositories, policies and partial restores · Reindex API and zero-downtime reindexing behind an alias · Rolling upgrades and version compatibility · Security: TLS, authentication, role-based access and field-level security · Indexing performance: bulk sizing, refresh interval, translog settings · Search performance: filters, caching, doc values and profiling with _profile · JVM heap, garbage collection and circuit breakers · Monitoring the cluster and what to alert on · Common production incidents and their signatures
How data gets in, and what sits around Elasticsearch. Ingest pipelines and processors inside the cluster, Logstash and Beats as external ingest paths, the language clients, and the Elastic Stack context — including where Kibana takes over as the query and visualisation surface, and how OpenSearch diverged.
Topics: Ingest pipelines: processors, simulate API and on-failure handling · Ingest node versus Logstash: choosing where to transform · Logstash: inputs, filters and outputs at a working level · Beats: Filebeat, Metricbeat and the module system · Language clients: Java, Python, JavaScript, Go · Bulk helpers and client-side retry behaviour · Elasticsearch and Kibana: where the boundary sits · Elasticsearch, OpenSearch and the fork: what actually differs · Runtime fields and schema-on-read · Cross-cluster search and replication basics
We rebuild the agenda around the tools you actually run.
Request a custom agendaDiagnose four searches that fail for analyser reasons — case, stemming, synonyms and keyword versus text — then build a custom analyser that fixes all four.
Translate ten written search requirements into Query DSL using query and filter context correctly, then use _explain to justify the top result of each.
Build multi-level nested aggregations with filters, cardinality and date_histogram that answer five analytical questions in a single call.
Break allocation deliberately, then use cluster health, cat APIs and allocation explain to diagnose and resolve every unassigned shard.
Change a mapping that cannot be changed in place: build the new index, reindex behind an alias, and cut over with no client configuration change.
Take a raw dataset through ingest pipeline, explicit mapping, custom analysis, tuned relevance and an aggregation-driven report, with an ILM and snapshot policy.
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
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.
I recently did a SRE Session with Rajesh Kumar from DevOps School and the session was great. Right from 1st day till day 15, we had a very interactive session. Rajesh clarified our doubts and the tool demos were excellent without any hiccups. He simplified the concepts while sticking to the content with a fine balance between theory and practice. Am convinced he is one of the best trainers for SRE & DevOps concepts.
The Rundeck developer session was excellent and highly engaging. I appreciated how well the session was structured, with the theoretical concepts explained clearly and in simple terms. What stood out most to me was the demo — it was both informative and enjoyable. I especially liked how Rajesh walked us through not only the happy path but also the sad path, showcasing common issues and sharing practical troubleshooting tips.
Rajesh's experience and knowledge are exceptional and we learnt invaluable practical knowledge which we can apply in our production environment. Incredibly friendly and gave us a fantastic insight both in-depth and at a high level of the Rundeck product.
Great learning experience from a very knowledgeable instructor with well-prepared course notes. The lab exercises on AWS instance work well to learn the hands-on side of the course.
| 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.