Private corporate batches, live online cohorts and 1-on-1 mentoring in the language and the JVM together — object design, collections, streams, concurrency, JDBC and running Java in production — 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 Java as a language on a runtime rather than as syntax in isolation: what the JVM does with a class at load time, why the memory model matters before you write your first synchronized block, and how bytecode, just-in-time compilation and garbage collection explain the behaviour engineers actually observe in production. Sessions work the full progression — types and control flow, object design with classes, interfaces, records and sealed types, generics and the collections framework, exceptions and resource handling, IO and NIO, then the functional half of modern Java with lambdas, streams, Optional and java.time. The concurrency module covers threads, the executor framework, CompletableFuture, the concurrent collections and virtual threads. Database work is taught through JDBC directly — drivers, connections, statements, result sets, metadata and CRUD — so that what a framework does later is visible rather than magical, and the final module works against a running application: heap dumps, garbage collection logs, Flight Recorder, and Java inside a container.
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 Java that means a trainer who has run it in production — the language and the JVM together — object design, collections, streams, concurrency, JDBC and running Java in production — 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 Java batchJava is a statically typed, object-oriented programming language and, just as importantly, a runtime platform. Source compiles to bytecode rather than to machine instructions, and that bytecode executes on the Java Virtual Machine, which loads classes, verifies them, manages memory and — through just-in-time compilation — turns the hot paths into native code while the program runs. This is why a Java application is portable across operating systems and why its performance characteristics are those of a managed runtime: excellent throughput once warm, with garbage collection and startup cost as the trade-offs.
The language has changed substantially since the versions most people learned. Lambdas and the Stream API made collection processing declarative. Optional gave a type-level answer to null. The module system, records, sealed types, pattern matching for switch, text blocks and local variable type inference removed a great deal of the ceremony Java was criticised for. Virtual threads changed the economics of concurrent server code by making a blocking thread cheap again. The six-month release cadence with long-term-support versions means a real project decision is now which Java to target, not whether to upgrade.
What keeps Java central is the platform around it. The standard library covers collections, IO and NIO, time, concurrency and JDBC for database access. Maven and Gradle handle builds and dependencies; JUnit and Mockito handle testing. Spring, Jakarta EE, Hibernate, Kafka clients, Hadoop and Spark are all Java or JVM projects, which means enterprise back ends, Android applications, data platforms and streaming systems all sit on the same runtime — and the same skills in reading a heap dump or a garbage collection log apply across all of them.
Java runs a very large share of the systems organisations cannot switch off: banking cores, insurance platforms, telecom billing, retail back ends, government systems and the data infrastructure underneath analytics. That installed base is not shrinking, and it generates sustained demand for engineers who can both maintain it and modernise it.
The modernisation part is where the current opportunity sits. A great deal of production Java was written against Java 8 idioms and is now being moved onto supported long-term-support releases, restructured into services, and containerised. That work needs people who understand the newer language features well enough to use them properly rather than cosmetically, who know what the module system and the removed internal APIs will break, and who can reason about memory and garbage collection when an application is suddenly running inside a container with a hard limit.
The second driver is that Java skills transfer unusually well. The JVM underneath Kotlin, Scala and Clojure is the same; the concurrency model, the memory model, the profiling tools and the build ecosystem are shared. An engineer who genuinely understands the platform is employable across a much wider surface than the language alone suggests.
What you are actually programming against. JDK, JRE and JVM distinguished properly; the compile-to-bytecode model; class loading, verification and linking; just-in-time compilation and why a Java application is slow for its first few seconds; the memory areas; and the release train that decides which Java version a project should target.
Topics: JDK, JRE and JVM: what each contains · Source to bytecode to native: the compilation model · Class loading, verification, linking and initialisation · Class loaders and the delegation model · Just-in-time compilation, tiered compilation and warm-up · JVM memory areas: heap, stack, metaspace, code cache · Garbage collection at a conceptual level · The six-month release cadence and long-term-support versions · Choosing a JDK distribution · Setting up a development environment and an IDE · javac, java, jshell and the command-line tools
The foundation, taught with the traps included. Primitives against their wrappers and the autoboxing cost; integer overflow and floating point behaviour engineers get bitten by; arrays; control flow including enhanced switch; and strings, where the pool, immutability and the difference between concatenation strategies actually matter for performance.
Topics: Primitives, wrappers, autoboxing and its cost · Integer overflow, floating point precision and BigDecimal · var and local variable type inference · Operators, precedence and the ternary · Conditionals, loops and labelled breaks · Enhanced switch expressions and pattern matching · Arrays, multidimensional arrays and the Arrays utility class · Strings: immutability, the string pool and interning · StringBuilder and concatenation performance · Text blocks and formatting · Enums and enums with behaviour · Varargs and method overload resolution
Designing types rather than just declaring them. Classes, constructors and initialisation order; encapsulation; inheritance and polymorphism with the cases where composition is the better answer; interfaces with default and static methods; abstract classes; then the modern additions — records for data carriers and sealed types for closed hierarchies — and the object contracts every class inherits.
Topics: Classes, fields, methods and constructors · Initialisation order, instance and static initialiser blocks · Encapsulation and access modifiers · Inheritance, method overriding and super · Polymorphism and dynamic dispatch · Composition over inheritance, with real examples · Interfaces, default methods and static methods · Abstract classes and when to prefer each · Records as transparent data carriers · Sealed classes and interfaces · equals, hashCode and toString contracts · Immutability and defensive copying · Nested, inner, local and anonymous classes · Object cloning and why it is usually the wrong tool
The part of the standard library used in every non-trivial program. Generics, type erasure and what it prevents; bounded types and wildcards with the producer-extends, consumer-super rule; then the collection interfaces and implementations compared by actual behaviour — ordering, null handling, iteration cost and thread safety — and the utility methods that shorten most code.
Topics: Generic classes, methods and type parameters · Type erasure and its consequences · Bounded type parameters and wildcards · Producer extends, consumer super · The collection hierarchy: Collection, List, Set, Queue, Map · ArrayList vs LinkedList, and why the answer is usually ArrayList · HashSet, LinkedHashSet and TreeSet · HashMap internals, load factor and collision behaviour · LinkedHashMap, TreeMap and NavigableMap · Deque, PriorityQueue and the queue implementations · Comparable, Comparator and sorting · Iterator, ListIterator and ConcurrentModificationException · Collections and List.of, Map.of and immutable factories · Choosing a collection for a stated access pattern
Handling failure and talking to the outside world. The exception hierarchy, checked against unchecked and the genuine argument on both sides, try-with-resources and AutoCloseable, custom exceptions that carry context, and then IO: streams and readers, the NIO.2 file APIs, serialisation and its risks, and character encoding, which causes more production bugs than it should.
Topics: The Throwable hierarchy: Error, Exception, RuntimeException · Checked versus unchecked exceptions and the design argument · try, catch, finally and multi-catch · try-with-resources and AutoCloseable · Suppressed exceptions and exception chaining · Designing custom exceptions that carry context · Anti-patterns: swallowing, logging-and-rethrowing, catching Exception · Byte streams and character streams · Buffering and why unbuffered IO is slow · NIO.2: Path, Files and directory walking · Character encoding, charsets and the default charset trap · Serialisation, transient fields and its security risks · Working with JSON and properties files
Modern Java's declarative half. Functional interfaces and lambdas, method references, and the built-in function types; the Stream API from source through intermediate operations to terminal operations, with collectors, grouping and reduction; Optional used as designed rather than as a null check; and java.time, which finally made date and time handling correct.
Topics: Functional interfaces and lambda syntax · Method and constructor references · Function, Supplier, Consumer, Predicate and the primitive variants · Stream sources, intermediate and terminal operations · map, filter, flatMap and the laziness model · Collectors: toList, joining, groupingBy, partitioningBy, teeing · Reduction, summary statistics and custom collectors · Parallel streams, and when they actually help · Optional: creation, mapping, and how not to use it · java.time: Instant, LocalDate, LocalDateTime, ZonedDateTime, Duration, Period · Time zones, daylight saving and formatting · Refactoring imperative loops into streams, and when not to
The subject that separates competent Java from safe Java. The memory model, visibility and happens-before before any locking is discussed; threads and their lifecycle; synchronized, volatile and the lock objects; the executor framework as the correct abstraction; concurrent collections and atomics; CompletableFuture for composition; then virtual threads and what they change for server workloads.
Topics: The Java memory model: visibility, ordering and happens-before · Threads, lifecycle, interruption and daemon threads · Race conditions, deadlock, livelock and starvation · synchronized, intrinsic locks and volatile · ReentrantLock, ReadWriteLock and Condition · The executor framework: thread pools, sizing and rejection policies · Callable, Future and shutdown handling · Concurrent collections and atomic classes · CompletableFuture and composing asynchronous work · The fork/join framework and work stealing · Virtual threads and structured concurrency · Thread confinement, immutability and avoiding shared state · Testing and debugging concurrent code
Talking to a database directly, so that what an ORM does later is visible rather than mysterious. JDBC architecture and driver types, installing the driver, obtaining connections, the three statement types and why prepared statements are both faster and the answer to SQL injection, result sets, metadata, transactions, and connection pooling.
Topics: Java database connectivity and JDBC architecture · Driver types, and the Type 4 driver for MySQL · Installing the MySQL connector or ojdbc driver and the classpath · DriverManager, DataSource and the Connection object · Statement, PreparedStatement and CallableStatement · Why PreparedStatement prevents SQL injection · The ResultSet interface and its methods · ResultSetMetaData and its methods · DatabaseMetaData and its methods · Sample programs performing CRUD operations · Transactions, commit, rollback and isolation levels · Batch updates and performance · Connection pooling with HikariCP · Where JPA and Hibernate take over, and what they generate
Turning code into a deliverable. Maven and Gradle project structure, dependency resolution and conflict mediation, the build lifecycle and useful plugins; JUnit 5 with parameterised tests and assertions; Mockito for isolation and its limits; coverage as a signal rather than a target; then packaging — fat jars, the module system, jlink and container images.
Topics: Maven project structure, POM and the build lifecycle · Gradle and the build script model · Dependency resolution, scopes, transitive dependencies and conflict mediation · Dependency locking and reproducible builds · Multi-module projects · JUnit 5: lifecycle, assertions, assumptions, parameterised and nested tests · Mockito: mocks, stubs, spies, argument captors and when not to mock · Test doubles, integration tests and Testcontainers · Code coverage with JaCoCo, and its honest limits · Static analysis: SpotBugs, Checkstyle, SonarQube quality gates · Packaging: jars, fat jars and the manifest · The module system, module-info and the migration path · jlink and custom runtime images · Building container images for Java applications
What happens after deployment. Garbage collectors and how to choose between them; reading garbage collection logs; heap dumps and finding a leak; thread dumps and diagnosing a stall; Flight Recorder and profiling; JVM flags that matter and the many that do not; and the container question — heap sizing under a cgroup limit, startup time, and what breaks when memory is capped.
Topics: Garbage collection algorithms: G1, Parallel, ZGC, Shenandoah · Generational collection, allocation and promotion · Choosing and configuring a collector for a workload · Reading garbage collection logs and pause distributions · Heap sizing, and why the default is often wrong · Heap dumps: capturing and analysing a memory leak · Thread dumps: capturing and diagnosing a stall or deadlock · Java Flight Recorder and Mission Control · Profiling: CPU, allocation and lock contention · JVM flags that matter, and cargo-cult flags that do not · Java in containers: cgroup awareness and heap percentage flags · Startup time, class data sharing and ahead-of-time options · JMX, metrics and application observability · Common production failure modes and their signatures
We rebuild the agenda around the tools you actually run.
Request a custom agendaTake a deep inheritance tree with broken equals and hashCode, rebuild it with composition, interfaces, records and sealed types, and prove the contracts with tests.
Benchmark list, set, map and deque implementations against a stated access pattern, then justify the choice from the measurements rather than from habit.
Diagnose a race condition and a deadlock in running code, fix both, then migrate the component from a thread pool to virtual threads and measure the difference.
Build a data access layer with Statement, demonstrate a working SQL injection against it, then rebuild with prepared statements, transactions and a connection pool.
Capture a heap dump from a leaking application, find the retaining path, fix the leak, and confirm with garbage collection logs that the pattern is gone.
Deliver a complete Java component — designed types, streams, concurrent processing, JDBC persistence, full test suite, reproducible build and a tuned runtime configuration.
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.