Private corporate batches, live online cohorts and 1-on-1 mentoring in schemas, validation, API contracts and configuration correctness in JSON — 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 JSON as a contract rather than a syntax — the grammar and its genuine traps, then JSON Schema in depth, from types and constraints through composition, references and conditional subschemas to draft differences between validators. Sessions cover the operational side directly: validating configuration in CI so a bad file fails a build instead of a deployment, defining API contracts with OpenAPI and generating typed clients from them, querying and reshaping payloads with jq, structured JSON logging, and the compatibility rules that decide whether a schema change is safe to ship.
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 JSON that means a trainer who has run it in production — schemas, validation, API contracts and configuration correctness in JSON — 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 JSON batchJSON — JavaScript Object Notation — is a text format for structured data with a grammar small enough to fit on a page: objects, arrays, strings, numbers, true, false and null. It has no schema, no comments, no date type, no integer type and no way to express a reference. That minimalism is why it became the default interchange format for HTTP APIs, configuration files, log records, message payloads, infrastructure state and CI pipeline definitions across every language and runtime in use.
The same minimalism is the source of the problems. Because JSON carries no schema, nothing in the format tells you whether a field is required, what values it may hold, or whether removing it breaks a consumer. Because numbers are doubles by specification, a 64-bit identifier can silently lose precision crossing a language boundary. Because there are no comments and no trailing commas, hand-edited configuration files break in ways that are trivial to cause and tedious to diagnose. And because duplicate keys and key ordering are underspecified, two parsers can legitimately disagree about the same document.
The discipline that fixes this is JSON Schema, and everything built on it. A schema states the shape a document must have, validators enforce it, editors use it for completion, CI uses it as a gate, and OpenAPI uses a subset of it to define the request and response contract of an entire API. Around that sit the operational tools: jq for querying and transforming, JSON Pointer and JSON Patch for addressing and modifying documents precisely, JSON Lines for streaming records, and structured JSON logging for machine-readable operations. Treated as a contract rather than a convenience, JSON stops being a source of production surprises.
Almost every integration an organisation owns is a JSON document crossing a boundary. Service-to-service calls, webhooks, event payloads, Terraform state, Kubernetes manifests rendered from JSON, CI configuration, feature flags, audit logs and cloud API responses are all JSON, and each one is a contract that two systems have agreed on — usually informally, and usually only in documentation that has drifted.
The cost of that informality is measurable. Contract drift is one of the most common causes of integration incidents: a field is renamed, a type changes from string to number, an optional field becomes required, and the failure surfaces in someone else's service at deployment time. Configuration is worse still, because a malformed or semantically invalid config file usually fails at start-up in production rather than in review, where a schema would have caught it in seconds.
What closes the gap is treating schemas as code. Publishing a schema alongside every API and every config format, validating in CI, generating client types from the contract, and running compatibility checks before a change merges turns an entire class of incidents into build failures. That is engineering practice rather than syntax, and it is what this course teaches.
JSON exactly as specified, and everything the specification leaves open. The grammar and value types, encoding and escaping, then the genuine sources of production defects: number precision, absent date and binary types, duplicate keys, ordering, and the difference between a missing field and a null one.
Topics: The JSON grammar — object, array, string, number, true, false and null · UTF-8 encoding, escaping and Unicode handling · Numbers as doubles, and losing a 64-bit identifier · No date type — ISO 8601 as the convention · Binary data, base64 and payload size · Duplicate keys, key ordering and parser disagreement · Missing, null and empty — three different things · Whitespace, minification and canonical forms · JSON compared with YAML, TOML, XML and Protocol Buffers
Parsing and serialising across the runtimes an estate actually uses, and the boundary discipline that stops a payload becoming a runtime failure. Serialisation options, streaming large documents, JSON Lines for record streams, safe parsing, and the errors worth catching explicitly.
Topics: Parsing and serialising in JavaScript, Python and the JVM · Serialisation control — field naming, omission, custom encoders · Round-trip losses and what does not survive serialisation · Streaming parsers for documents too large to hold in memory · JSON Lines and newline-delimited records · Safe parsing — size limits, depth limits and error handling · Reading and writing JSON from the command line · Pretty printing, minifying and stable output for diffs
The core of the course. Writing a schema that actually constrains, rather than one that permits everything. Types and required fields, string, numeric and array constraints, enums and formats, additionalProperties and why omitting it is usually a defect, then identifiers, references and reusable definitions.
Topics: What JSON Schema is, and the draft versions in use · type, properties, required and additionalProperties · String constraints — pattern, minLength, maxLength and format · Numeric constraints, integer versus number, and multipleOf · Arrays — items, prefixItems, minItems, maxItems and uniqueItems · Enums and constant values · Nested objects and reusable definitions · $id, $ref and reference resolution · Choosing a validator and the draft it supports
Modelling documents that are not a single flat shape. allOf, anyOf, oneOf and not, discriminated unions, conditional subschemas with if, then and else, dependent requirements, recursion, and the practical problem of turning validator output into an error message an engineer can act on.
Topics: allOf, anyOf, oneOf and not, and how each fails · Discriminated unions and polymorphic payloads · Conditional validation with if, then and else · dependentRequired and dependentSchemas · Recursive and self-referencing structures · Schema composition across files and bundling · Custom keywords, formats and extension points · Readable validation errors and error mapping · Performance of large schemas and compiled validators
Where schemas pay for themselves fastest. Validating configuration files before they reach a runtime, per-environment schemas and defaults, editor completion through schema association, precise updates with JSON Pointer, Patch and Merge Patch, and reviewable diffs — plus the rule that secrets never live in the file.
Topics: Validating configuration in pre-commit hooks and in CI · Required keys, defaults and per-environment variation · Schema association in editors and the public schema store · JSON Pointer for addressing a location in a document · JSON Patch and JSON Merge Patch for controlled updates · Canonicalisation and stable ordering for reviewable diffs · Secrets — why they never belong in a config file, and what to do instead · Configuration drift between environments · Failing fast at start-up on invalid configuration
JSON as the interface between services. Modelling requests and responses, OpenAPI and the JSON Schema subset it uses, standard error payloads, nullability and optionality, pagination and envelope conventions, then generating typed clients and detecting breaking changes before a merge.
Topics: Modelling request and response bodies as contracts · OpenAPI and the JSON Schema subset it defines · Error payload conventions and problem details · Optionality, nullability and default values · Pagination, envelopes and metadata patterns · Generating typed clients and server stubs from a contract · Contract testing between producer and consumer · Mock servers driven by the schema · Detecting breaking changes in a pipeline
The day-to-day operational half. jq from filters and pipes through to reduce and grouping, alternatives such as JSONPath and JMESPath, structured JSON logging and how to design a log record, querying those records in a log platform, and the security concerns that come with parsing untrusted documents.
Topics: jq basics — filters, pipes, selection and indexing · jq in depth — map, select, reduce, to_entries and grouping · jq inside pipeline scripts and shell automation · JSONPath and JMESPath, and where each fits · Designing a structured log record — fields, levels, correlation identifiers · Querying JSON logs in Elasticsearch, CloudWatch or Splunk · Diffing and comparing documents meaningfully · Untrusted input — depth limits, size limits and parser denial of service · Deserialisation risks and content-type enforcement
We rebuild the agenda around the tools you actually run.
Request a custom agendaReproduce number precision loss, duplicate-key disagreement and null-versus-missing confusion against real parsers, then write the conventions that prevent each.
Take a schema that accepts almost anything and tighten it until it rejects every malformed variant, with readable error messages for each failure.
Add schema validation to a repository's configuration files, wire it into pre-commit and CI, and give authors editor completion from the same schema.
Describe an existing API in OpenAPI, generate a typed client, stand up a mock server from the same document, and make a breaking change fail the pipeline.
Use jq to filter, group, reduce and reshape a large API response into a report, then embed the same filters in a pipeline script.
Publish schemas for one API and one config format, validate both in CI, generate clients from the contract, and define the compatibility policy for future changes.
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.