Java Full Stack with Microservices & GenAI

You can write high-performance, concurrent Java 21 code using records, sealed classes, and virtual threads.

1. Java fundamentals and object-oriented design done right90 min
   • Object initialization
   • Immutable domain objects
   • Access modifiers
   • Composition over inheritance
2. Collections, generics and the Streams API120 min
   • Collection hierarchy
   • Type erasure
   • Stream operations
   • Collectors and groupingBy
3. Records, sealed classes and pattern matching120 min
   • record keyword
   • sealed permits
   • switch pattern matching
   • instanceof bindings
4. Functional programming and Optional90 min
   • Functional interfaces
   • Lambda expressions
   • Optional null-safety
   • Method references
5. Concurrency: threads, executors, CompletableFuture and virtual threads (Project Loom)150 min
   • ExecutorService
   • CompletableFuture chaining
   • Thread.ofVirtual()
   • Structured concurrency
6. Clean code, SOLID principles and effective exception handling120 min
   • SOLID principles
   • Custom exception hierarchies
   • Try-with-resources
   • Checkstyle rules

Hands-on project: Refactor a legacy payment processing module to use Java 21 records, pattern matching, and virtual threads, reducing thread overhead by 80% under concurrent load.

You can author robust unit and integration test suites using JUnit 5, Mockito, and Testcontainers.

1. Maven and Gradle, and dependency management90 min
   • pom.xml lifecycle
   • build.gradle plugins
   • Dependency convergence
   • Artifact resolution
2. Unit testing with JUnit 5 and Mockito120 min
   • @Test and @ParameterizedTest
   • Mockito @Mock and @InjectMocks
   • ArgumentCaptor
   • Assertion libraries
3. Test-driven development and the testing pyramid90 min
   • Red-Green-Refactor cycle
   • Test pyramid breakdown
   • Behavior-driven assertions
   • Mockist vs classicist TDD
4. Integration testing with Testcontainers120 min
   • @Testcontainers annotation
   • PostgreSQLContainer setup
   • DynamicPropertySource
   • Database reset scripts
5. Code coverage (JaCoCo) and static analysis (SonarQube)90 min
   • JaCoCo maven plugin
   • Code smell detection
   • Quality gate rules
   • Bug pattern analysis
6. Lombok, MapStruct and productivity tooling90 min
   • @Data and @Builder
   • MapStruct interface mapping
   • Annotation processing
   • IDE configuration

Hands-on project: Implement an automated test suite for an order management service achieving 90% JaCoCo code coverage with isolated Postgres containers via Testcontainers.

You can design relational schemas, optimize Hibernate queries, and manage database migrations safely.

1. Relational modelling and advanced SQL120 min
   • Foreign keys and constraints
   • Indexes and B-Trees
   • Window functions
   • Common Table Expressions
2. JDBC and connection pooling with HikariCP90 min
   • DataSource configuration
   • HikariCP pool sizing
   • Connection leak detection
   • Statement pooling
3. JPA and Hibernate in depth120 min
   • Entity lifecycle states
   • First and second-level cache
   • Cascade types
   • Dirty checking mechanics
4. Spring Data JPA, transactions and isolation levels120 min
   • @Transactional propagation
   • Isolation anomalies
   • PagingAndSortingRepository
   • Custom JPQL queries
5. Solving the N+1 problem and query optimisation90 min
   • JOIN FETCH clauses
   • @EntityGraph
   • Hibernate statistics logging
   • Batch fetching size
6. Schema migrations with Flyway / Liquibase90 min
   • V__migration scripts
   • Checksum validation
   • Repeatable migrations
   • Rollback strategies

Hands-on project: Configure a Spring Data JPA persistence layer with HikariCP, resolve N+1 query bottlenecks, and execute zero-downtime schema upgrades using Flyway.

You can build secure REST APIs using Spring Boot 3, DTO validation, and OAuth2/Keycloak integration.

1. Spring IoC, dependency injection and the bean lifecycle90 min
   • ApplicationContext
   • Bean scopes
   • @PostConstruct and @PreDestroy
   • Conditional configuration
2. Spring Boot 3, Jakarta EE and auto-configuration90 min
   • spring.factories vs imports
   • Jakarta namespace migration
   • Custom starters
   • Property binding
3. Configuration, profiles and externalised config90 min
   • application.yml profiles
   • @ConfigurationProperties
   • Environment variables
   • Secret injection
4. Robust REST APIs with DTOs and validation120 min
   • @RestController mechanics
   • Bean Validation annotations
   • DTO mapping patterns
   • ResponseEntity builders
5. Global exception handling and API versioning90 min
   • @ControllerAdvice
   • Problem Details RFC 7807
   • URL vs header versioning
   • Error response contracts
6. OpenAPI/Swagger documentation and Spring Boot Actuator90 min
   • springdoc-openapi
   • Actuator health endpoints
   • Custom health indicators
   • Metrics export
7. Authentication and authorization model90 min
   • SecurityFilterChain
   • AuthenticationManager
   • GrantedAuthority mapping
   • Stateless sessions
8. JWT and stateless security90 min
   • Signed JWT decoding
   • NimbusJwtDecoder
   • Claims extraction
   • Token expiration handling
9. OAuth2 / OpenID Connect with Keycloak120 min
   • Authorization Code flow
   • Keycloak realm setup
   • Resource server configuration
   • Client credentials grant
10. Method-level security and role-based access control90 min
    • @PreAuthorize
    • @Secured annotations
    • SpEL security expressions
    • Custom permission evaluators
11. CORS, CSRF and secure HTTP headers90 min
    • CorsConfigurationSource
    • CSRF token repository
    • Content Security Policy
    • HSTS headers
12. Securing service-to-service communication90 min
    • mTLS configuration
    • Shared secret tokens
    • Feign client interceptors
    • Credential propagation

Hands-on project: Build a production-ready inventory service with Spring Boot 3, global exception handling, OpenAPI documentation, and stateless JWT security backed by Keycloak.

You can build responsive, type-safe single-page applications in React and TypeScript that consume backend APIs.

1. React fundamentals with TypeScript120 min
   • JSX syntax
   • Component props typing
   • Functional components
   • Type definitions
2. Hooks, component patterns and state120 min
   • useState and useEffect
   • useContext and custom hooks
   • State lifting
   • Performance memoization
3. Data fetching and caching with React Query120 min
   • useQuery hooks
   • Mutation handling
   • Cache invalidation
   • Optimistic updates
4. Routing, forms and validation120 min
   • React Router DOM
   • Controlled forms
   • React Hook Form
   • Zod schema validation
5. Authentication flows and protected routes90 min
   • JWT storage in memory
   • Auth context provider
   • Private route wrappers
   • Axios interceptors for refresh
6. Integrating cleanly with your back-end APIs90 min
   • API client structuring
   • Error boundary handling
   • Environment configuration
   • CORS troubleshooting

Hands-on project: Build a React and TypeScript client featuring React Query data fetching, form validation with Zod, and protected routing linked to your backend authentication service.

You can solve complex coding interview problems and design large-scale distributed systems.

1. Big-O time & space complexity, in plain language90 min
   • Asymptotic analysis
   • Worst and average case
   • Memory footprint rules
   • Complexity trade-offs
2. Arrays, strings and hashing120 min
   • Two-pointer technique
   • Sliding window pattern
   • HashMap internals
   • Prefix sum arrays
3. Linked lists, stacks and queues120 min
   • Pointer manipulation
   • Monotonic stack
   • Queue circular buffers
   • LRU Cache design
4. Recursion and binary search90 min
   • Call stack mechanics
   • Binary search invariants
   • Search on answer space
   • Backtracking templates
5. Sorting algorithms and when to use them90 min
   • Merge sort
   • Quick sort partitioning
   • Priority queues
   • Custom comparators
6. Guided problem practice120 min
   • LeetCode pattern drills
   • Mock interview structure
   • Code walkthroughs
   • Edge case identification
7. Trees and binary search trees120 min
   • Tree node structures
   • BST insertion/deletion
   • Balanced trees (AVL concepts)
   • Trie implementation
8. Tree traversals (DFS & BFS)90 min
   • Pre/in/post-order DFS
   • Level-order BFS
   • Queue-based iteration
   • Recursion elimination
9. Graphs and how to search them120 min
   • Adjacency list representation
   • BFS shortest path
   • DFS cycle detection
   • Topological sorting
10. Dynamic programming from first principles120 min
    • Memoization vs tabulation
    • State transition equations
    • Knapsack variations
    • Longest common subsequence
11. What 'design' really means for code90 min
    • Maintainability metrics
    • Coupling and cohesion
    • Interface segregation
    • Refactoring smells
12. Object-oriented thinking90 min
    • Domain modeling
    • Encapsulation rules
    • Polymorphic dispatch
    • State patterns
13. SOLID principles in plain English90 min
    • Single responsibility
    • Open-closed principle
    • Liskov substitution
    • Dependency inversion
14. Common design patterns120 min
    • Factory and Builder
    • Strategy pattern
    • Observer pattern
    • Decorator pattern
15. UML and modelling a problem90 min
    • Class diagrams
    • Sequence diagrams
    • State machine diagrams
    • Component mapping
16. Designing a real object model (e.g., a booking or parking system)120 min
    • Requirement gathering
    • Core class breakdown
    • Concurrency handling
    • Extensibility review
17. The building blocks: servers, databases, caches, queues120 min
    • DNS and IP routing
    • Relational vs NoSQL trade-offs
    • Redis cache layers
    • Message brokers
18. Load balancing and horizontal scaling90 min
    • Round-robin vs least-conn
    • Layer 4 vs Layer 7 proxies
    • Session stickiness
    • DNS load balancing
19. Database replication and sharding120 min
    • Master-slave replication
    • Consistent hashing
    • Sharding key selection
    • CAP theorem application
20. Designing real systems (URL shortener, chat app, news feed)120 min
    • Back-of-envelope estimation
    • API design specification
    • Data flow diagrams
    • Bottleneck mitigation
21. Trade-offs, bottlenecks and reliability90 min
    • Single points of failure
    • Graceful degradation
    • Rate limiting algorithms
    • Idempotency keys
22. How to answer a system-design interview, step by step90 min
    • Requirement clarification
    • High-level sketch
    • Deep dive into components
    • Trade-off discussion

Hands-on project: Design and document a high-level architecture for a global media streaming platform handling 100k requests/sec, accompanied by core algorithmic problem solutions in Java.

You can decompose monoliths into microservices using DDD principles, service discovery, and Resilience4j.

1. Monolith vs microservices trade-offs90 min
   • Organizational scaling
   • Deployment independence
   • Distributed complexity
   • Network latency cost
2. Domain-Driven Design: bounded contexts and aggregates120 min
   • Ubiquitous language
   • Bounded context mapping
   • Entities vs value objects
   • Aggregate roots
3. Decomposing a system into services90 min
   • Decomposition by business capability
   • Subdomain analysis
   • Service boundary rules
   • Anti-corruption layers
4. Database-per-service and data ownership90 min
   • Data isolation principles
   • Distributed joins elimination
   • API composition
   • CQRS read models
5. API design, contracts and versioning90 min
   • Consumer-driven contracts
   • REST maturity model
   • Backward compatibility
   • Schema evolution
6. Inter-service communication: REST, gRPC and async120 min
   • Spring Cloud OpenFeign
   • Protocol Buffers and gRPC
   • HTTP/2 multiplexing
   • Synchronous vs asynchronous
7. Service discovery with Eureka90 min
   • Eureka server setup
   • Client heartbeat registration
   • Registry replication
   • Client-side caching
8. API Gateway with Spring Cloud Gateway120 min
   • Gateway route predicates
   • Global request filters
   • Path rewriting
   • Token relay configuration
9. Centralised configuration90 min
   • Spring Cloud Config Server
   • Git repository backend
   • Dynamic property refresh
   • Encryption of sensitive values
10. Circuit breakers, retries and bulkheads with Resilience4j120 min
    • Circuit breaker states
    • Fallback method configuration
    • Retry with exponential backoff
    • Bulkhead thread isolation
11. Rate limiting and client-side load balancing90 min
    • Token bucket algorithm
    • Request rate limiter filter
    • Spring Cloud LoadBalancer
    • Round-robin execution
12. Distributed configuration and secrets90 min
    • Environment-specific profiles
    • HashiCorp Vault integration
    • Runtime config reloading
    • Secret rotation policies

Hands-on project: Decompose an e-commerce monolith into bounded contexts using Spring Cloud Gateway, Eureka service discovery, and Resilience4j circuit breakers.

You can build reliable event-driven systems with Apache Kafka, sagas, and Redis caching strategies.

1. Messaging fundamentals and when to go asynchronous90 min
   • Pub-sub vs point-to-point
   • Decoupling temporal dependencies
   • Backpressure handling
   • Event-driven architecture
2. Apache Kafka: topics, partitions and consumer groups120 min
   • Broker architecture
   • Topic partition assignment
   • Consumer group rebalancing
   • Offset management
3. Producers, consumers and schema management120 min
   • KafkaTemplate configuration
   • @KafkaListener annotations
   • Confluent Schema Registry
   • Avro serialization
4. The transactional outbox pattern120 min
   • Dual-write problem
   • Outbox table schema
   • Polling publisher pattern
   • Debezium CDC basics
5. Sagas for distributed transactions120 min
   • Orchestration-based saga
   • Choreography-based saga
   • Compensating transactions
   • Idempotent consumers
6. Dead-letter queues and error handling90 min
   • DeadLetterPublishingRecoverer
   • Non-blocking retries
   • Poison pill handling
   • Error routing
7. Caching strategies with Redis (cache-aside, write-through)90 min
   • Cache-aside pattern
   • Write-through caching
   • RedisTemplate setup
   • Serialization config
8. Distributed caching and cache invalidation90 min
   • TTL expiration policies
   • Cache stampede prevention
   • Pub-sub cache eviction
   • Distributed locks with Redisson
9. Database indexing and query tuning90 min
   • EXPLAIN ANALYZE output
   • Composite index design
   • Partial indexes
   • Query execution plans
10. Pagination and efficient data access90 min
    • Offset vs cursor pagination
    • Keyset pagination performance
    • Infinite scroll backend
    • Slice vs Page objects
11. JVM tuning and profiling90 min
    • Garbage collectors (G1, ZGC)
    • Heap dump analysis with VisualVM
    • Memory leak detection
    • JVM flag optimization
12. Load testing with JMeter / Gatling90 min
    • Gatling simulation scripts
    • Ramp-up user load
    • Throughput measurement
    • Latency percentiles

Hands-on project: Implement asynchronous order fulfillment across microservices using Apache Kafka, the transactional outbox pattern, and distributed Redis caching.

You can containerize, orchestrate, deploy, and monitor production microservices on Kubernetes and AWS.

1. The three pillars of observability90 min
   • Metrics vs logs vs traces
   • Observability maturity model
   • High cardinality data
   • Actionable alerting
2. Metrics with Micrometer and Prometheus120 min
   • Micrometer registry
   • Custom counter and timer metrics
   • Prometheus scrape config
   • PromQL queries
3. Dashboards and alerting in Grafana90 min
   • Grafana panel configuration
   • Alertmanager integration
   • PagerDuty webhook setup
   • SLO burn-rate alerts
4. Centralised logging (ELK / Loki)90 min
   • Logback JSON encoder
   • Promtail log scraping
   • Grafana Loki queries
   • Log aggregation patterns
5. Distributed tracing with OpenTelemetry and Jaeger120 min
   • OpenTelemetry Java agent
   • Trace and span context propagation
   • W3C traceparent headers
   • Jaeger collector setup
6. Health checks, SLOs and SLIs90 min
   • Readiness vs liveness probes
   • Service level indicators
   • Service level objectives
   • Error budget calculation
7. Docker and multi-stage image builds120 min
   • Dockerfile best practices
   • Multi-stage jar extraction
   • Distroless base images
   • Image vulnerability scanning
8. Docker Compose for local environments90 min
   • docker-compose.yml syntax
   • Service networking
   • Volume mounts for data
   • Healthcheck dependencies
9. Kubernetes: pods, deployments and services120 min
   • Kubernetes object manifests
   • ReplicaSets and pods
   • ClusterIP and NodePort services
   • Kubectl debugging commands
10. ConfigMaps, Secrets and ingress90 min
    • ConfigMap environment injection
    • Secret base64 encoding
    • Ingress-nginx controller
    • TLS termination
11. Liveness/readiness probes and horizontal autoscaling90 min
    • HTTP GET probes
    • Startup probe configuration
    • HorizontalPodAutoscaler
    • CPU/memory metrics server
12. Packaging and releasing with Helm90 min
    • Helm chart structure
    • values.yaml templating
    • Helm install and upgrade
    • Chart repository publishing
13. Git workflows and trunk-based development90 min
    • Branch protection rules
    • Pull request reviews
    • Semantic release versioning
    • Trunk-based workflow
14. CI/CD pipelines with Jenkins and GitHub Actions120 min
    • GitHub Actions workflow YAML
    • Jenkinsfile declarative syntax
    • Automated test execution
    • Container registry push
15. Automated testing and container image registries90 min
    • CI pipeline test stages
    • AWS ECR authentication
    • Image tagging strategies
    • Vulnerability gating
16. Infrastructure as Code with Terraform120 min
    • Terraform HCL syntax
    • AWS VPC and subnet modules
    • EKS cluster provisioning
    • Remote state management
17. Deploying to AWS (EKS)120 min
    • kubectl context configuration
    • AWS IAM authenticator
    • Cluster autoscaler setup
    • Persistent volume claims
18. Blue-green and canary deployments90 min
    • Blue-green switchover
    • Canary traffic shifting
    • Argo Rollouts introduction
    • Automated rollback triggers

Hands-on project: Containerize all microservices with multi-stage Dockerfiles, deploy via Helm charts to Kubernetes on AWS using Terraform, and configure Prometheus/Grafana monitoring.

You can defend a service with a layered test suite that runs in CI and catches real regressions.

1. The test pyramid applied to Spring Boot90 min
   • Unit vs slice vs integration
   • @WebMvcTest and @DataJpaTest
   • What not to mock
2. Integration tests on real infrastructure90 min
   • Testcontainers Postgres
   • @DynamicPropertySource
   • Reusable containers
3. Contract testing between services90 min
   • Consumer-driven contracts
   • Stub runner
   • Breaking-change detection
4. Coverage, mutation testing and CI gates90 min
   • JaCoCo thresholds
   • PIT mutation score
   • Flaky-test quarantine

Hands-on project: Bring a supplied Spring Boot service to meaningful coverage: JUnit 5 unit tests with Mockito, an integration test on a real Postgres via Testcontainers, a Spring Cloud Contract test against its consumer, and a CI gate that fails the build on a coverage drop.

You can secure a service with OAuth2 and show it resists the common OWASP attacks.

1. OAuth2 and OIDC in practice90 min
   • Authorization code with PKCE
   • Access vs refresh tokens
   • JWT validation and JWKS
2. Method and request authorisation90 min
   • SecurityFilterChain
   • @PreAuthorize with scopes
   • Deny-by-default
3. The OWASP risks that hit Java APIs90 min
   • Injection via JPQL
   • Broken object-level auth
   • SSRF in outbound calls
4. Secrets and supply chain90 min
   • Externalised configuration
   • Vault or sealed secrets
   • dependency-check and SBOM

Hands-on project: Put an API behind Keycloak using the OAuth2 resource-server starter with scope-based method security, move all secrets out of the repository into environment-backed config, and run an OWASP dependency scan that fails the build on a critical CVE.

You can find a latency problem with a profiler and prove the fix with numbers.

1. Measuring before optimising90 min
   • p50, p95 and p99
   • k6 or Gatling load profiles
   • Baseline then change one thing
2. Profiling and JVM tuning90 min
   • async-profiler flame graphs
   • Heap vs GC pauses
   • G1 and heap sizing
3. Caching that does not go stale90 min
   • Caffeine and @Cacheable
   • TTL and eviction policy
   • Cache stampede
4. Resilience patterns under failure90 min
   • Circuit breaker and bulkhead
   • Timeouts and retry with jitter
   • Graceful degradation

Hands-on project: Load-test an endpoint to establish a p99 baseline, profile it with async-profiler to locate the hot path, fix it with a Caffeine cache and an index, add a Resilience4j circuit breaker on its downstream call, and report before-and-after p99.

You can integrate production-grade GenAI features using Spring AI, RAG over pgvector, and build a complete capstone project.

1. LLM fundamentals for engineers90 min
   • Tokenization mechanics
   • Context window limits
   • Temperature and top-p settings
   • API pricing models
2. Spring AI and LangChain4j120 min
   • ChatClient abstraction
   • Prompt templates
   • Structured output mapping
   • Provider configuration
3. Calling LLMs securely from Java services90 min
   • API key secret management
   • Rate limiting client calls
   • Timeout and retry handling
   • Fallback responses
4. Retrieval-augmented generation with a vector database (pgvector)120 min
   • Vector embedding generation
   • pgvector PostgreSQL extension
   • Cosine similarity search
   • Document chunking strategies
5. Embeddings, streaming responses and tool/function calling120 min
   • Flux streaming responses
   • Spring AI @Tool registration
   • Function calling execution loop
   • Token usage monitoring
6. Guardrails, evaluation, cost and token management90 min
   • Input/output guardrails
   • Prompt injection defense
   • Token usage auditing
   • Evaluation frameworks
7. The twelve-factor app and secrets management with Vault90 min
   • 12-factor methodology review
   • Stateless process design
   • Vault secret injection in K8s
   • Configuration separation
8. Zero-downtime deployments and feature flags90 min
   • Rolling update strategy
   • Readiness probe grace periods
   • Feature toggle architecture
   • Database migration safety
9. Resilience, graceful degradation and chaos-engineering basics90 min
   • Cascading failure prevention
   • Bulkhead isolation limits
   • Chaos engineering principles
   • Pod kill experiments
10. Designing the capstone: a multi-service, event-driven system with an AI feature120 min
    • Capstone specification review
    • Bounded context definition
    • Event contract design
    • AI feature integration plan
11. Building, containerising and deploying to Kubernetes with full observability150 min
    • End-to-end integration
    • Helm chart deployment
    • Prometheus metrics verification
    • Jaeger distributed trace check
12. Architecture review, portfolio and interview preparation120 min
    • Architecture defense
    • Resume and GitHub polishing
    • Mock system design interview
    • Career coaching session

Hands-on project: Build, containerize, and deploy a full-stack microservices e-commerce system with Kafka messaging, Spring AI RAG search, Kubernetes orchestration, and full OpenTelemetry tracing.