Java Full Stack Bootcamp with DSA & System Design

You can write robust, object-oriented Java programs using collections, generics, and lambdas.

1. Java syntax and object-oriented programming90 min
   • classes and objects
   • inheritance and polymorphism
   • interfaces and abstract classes
2. Collections and generics90 min
   • ArrayList and HashMap
   • bounded type parameters
   • Iterable and Iterator interfaces
3. Exceptions and the Streams API90 min
   • checked vs unchecked exceptions
   • try-with-resources
   • java.util.stream pipeline operations
4. Concurrency basics90 min
   • Runnable and Callable
   • ExecutorService
   • synchronization and thread safety
5. Clean, testable code90 min
   • naming conventions
   • SOLID principles overview
   • refactoring anti-patterns
6. Git and GitHub workflow90 min
   • git commit conventions
   • branching and merging
   • pull request workflows

Hands-on project: Build a command-line inventory management system in Java that reads data from CSV files, manages state with custom generics, and passes a full suite of JUnit unit tests.

You can manage dependencies with Maven and profile Java performance under load.

1. Functional Java and lambdas90 min
   • functional interfaces
   • lambda expressions
   • method references
2. Streams and Optional in depth90 min
   • intermediate vs terminal operations
   • Collectors groupingBy
   • Optional null safety
3. Maven and dependency management90 min
   • pom.xml lifecycle
   • dependency exclusion
   • SNAPSHOT vs RELEASE versions
4. Unit testing with JUnit90 min
   • assertions and annotations
   • parameterized tests
   • Mockito mocking fundamentals
5. Debugging and profiling90 min
   • IntelliJ debugger breakpoints
   • heap dumps
   • basic CPU profiling
6. Reading documentation and APIs90 min
   • Javadoc conventions
   • reading JDK source code
   • exploring third-party APIs

Hands-on project: Configure a multi-module Maven project with strict dependency scopes, writing automated unit and integration tests using JUnit 5.

You can design relational schemas, write complex SQL queries, and manage database migrations.

1. Relational modelling90 min
   • normalization forms (1NF, 2NF, 3NF)
   • primary and foreign keys
   • one-to-many and many-to-many relationships
2. SQL queries and joins90 min
   • INNER, LEFT, and RIGHT joins
   • GROUP BY and HAVING clauses
   • subqueries and CTEs
3. Transactions and indexing90 min
   • ACID properties
   • isolation levels
   • B-tree index optimization
4. JPA and Hibernate basics90 min
   • Entity mapping annotations
   • EntityManager lifecycle
   • lazy vs eager loading
5. Connecting Java to databases90 min
   • JDBC driver configuration
   • HikariCP connection pooling
   • handling SQL exceptions
6. Schema migrations with Flyway90 min
   • versioned migration naming
   • repeatable migrations
   • rollback strategies

Hands-on project: Design a normalized PostgreSQL schema for an e-commerce platform with foreign keys, indexes, and automated Flyway migration scripts.

You can build production-grade REST APIs using Spring Boot and Spring Data JPA.

1. Spring dependency injection90 min
   • IoC container
   • constructor injection
   • bean scopes and qualifiers
2. Spring Boot fundamentals90 min
   • spring-boot-starter dependencies
   • application.properties configuration
   • CommandLineRunner
3. Building REST APIs90 min
   • @RestController and HTTP mapping annotations
   • request bodies and path variables
   • ResponseEntity status codes
4. Validation and error handling90 min
   • javax.validation annotations
   • @ControllerAdvice global handlers
   • custom error response payloads
5. Spring Data JPA90 min
   • JpaRepository interfaces
   • derived query methods
   • @Query JPQL annotations
6. Testing your services90 min
   • @SpringBootTest integration tests
   • @WebMvcTest controller slices
   • MockMvc test execution

Hands-on project: Develop a RESTful backend service for a product catalog with pagination, global exception handling, and full Spring Data JPA persistence.

You can secure Spring Boot APIs with JWT authentication and build responsive React UIs.

1. Authentication and JWT90 min
   • stateless session management
   • JWT generation and validation filters
   • password hashing with BCrypt
2. Role-based access control90 min
   • authorities and roles
   • method security with @PreAuthorize
   • SecurityFilterChain configuration
3. React fundamentals and hooks90 min
   • JSX and component lifecycle
   • useState and useEffect
   • custom hooks
4. Consuming your APIs from React90 min
   • Axios HTTP client setup
   • handling loading and error states
   • asynchronous state updates
5. Forms, routing and auth flows90 min
   • React Router DOM configuration
   • controlled form components
   • local storage token caching
6. Connecting front-end to back-end90 min
   • CORS configuration in Spring
   • proxying API requests
   • end-to-end authentication flow

Hands-on project: Build a React single-page application with protected routes, axios interceptors for JWT tokens, and connect it to a secured Spring Boot backend.

You can analyze algorithmic complexity and solve array, string, and hashing interview problems.

1. What an algorithm is and why efficiency matters (Java)90 min
   • execution time measurement
   • memory allocation basics
   • worst-case vs average-case
2. Big-O time & space complexity, in plain language90 min
   • O(1), O(log n), O(n), O(n log n), O(n^2)
   • drop constants and lower-order terms
   • auxiliary space calculation
3. Arrays and strings90 min
   • contiguous memory layout
   • StringBuilder efficiency
   • in-place array modifications
4. Hashing: maps and sets90 min
   • hash function collision handling
   • HashMap internal bucket structure
   • HashSet frequency counting
5. The two-pointer and sliding-window patterns90 min
   • opposite direction pointers
   • variable-size sliding windows
   • subarray sum constraints
6. Your first guided coding problems90 min
   • two sum and valid anagram
   • longest substring without repeating characters
   • container with most water

Hands-on project: Implement 15 LeetCode-style problems in Java covering sliding window, two pointers, and frequency map patterns with O(n) complexity proofs.

You can manipulate linked lists, stacks, queues, and apply binary search and sorting.

1. Linked lists, explained simply90 min
   • singly and doubly linked lists
   • pointer manipulation safety
   • fast and slow pointer technique
2. Stacks and queues90 min
   • LIFO and FIFO operations
   • monotonic stack pattern
   • queue implementation using arrays
3. Recursion made intuitive90 min
   • call stack frames
   • base cases and inductive steps
   • tail recursion optimization
4. Binary search90 min
   • search space reduction
   • binary search on answer
   • handling duplicate elements
5. Sorting algorithms and when to use them90 min
   • merge sort and quick sort mechanics
   • stability in sorting
   • Java Collections.sort internals
6. Choosing the right data structure (guided practice)90 min
   • trade-off analysis
   • time-space complexity matching
   • mock coding drills

Hands-on project: Write robust Java implementations for linked list reversal, LRU cache using LinkedHashMap, and binary search variants under interview conditions.

You can traverse trees, explore graphs, and solve optimization problems using dynamic programming.

1. Trees and binary search trees90 min
   • binary tree node structure
   • BST insertion and search
   • balanced trees overview
2. Tree traversals (DFS & BFS)90 min
   • preorder, inorder, postorder recursive and iterative
   • level order traversal using queues
   • lowest common ancestor
3. Graphs and how to search them90 min
   • adjacency list representation
   • Breadth-First Search (BFS)
   • Depth-First Search (DFS) cycle detection
4. Dynamic programming from first principles90 min
   • overlapping subproblems and optimal substructure
   • memoization (top-down)
   • tabulation (bottom-up)
5. Common interview patterns90 min
   • coin change problem
   • longest increasing subsequence
   • matrix path counting
6. Company-style problem sets and mock rounds90 min
   • timed coding simulations
   • code review feedback
   • handling interviewer hints

Hands-on project: Solve 12 advanced problems involving binary tree traversals, Dijkstra shortest path, and 0/1 knapsack dynamic programming in Java.

You can decompose monoliths into decoupled microservices communicating via REST and messaging queues.

1. Monolith vs microservices, in plain terms90 min
   • scaling bottlenecks of monoliths
   • organizational coupling vs autonomy
   • operational complexity trade-offs
2. Splitting an application into services (Domain-Driven Design)90 min
   • bounded contexts
   • aggregate roots
   • database per service pattern
3. How services communicate: REST and async messaging90 min
   • synchronous HTTP vs asynchronous events
   • Spring Cloud OpenFeign
   • message broker concepts
4. Message queues and the API gateway90 min
   • Spring Cloud Gateway routing
   • request filtering and rate limiting
   • asynchronous pub-sub patterns
5. Caching, resilience and circuit breakers90 min
   • Resilience4j circuit breaker configuration
   • fallback methods
   • Redis caching integration
6. Deploying and testing microservices90 min
   • service discovery principles
   • distributed logging correlation IDs
   • integration testing multi-service setups

Hands-on project: Split a monolithic application into two independent Spring Boot microservices communicating over REST with Feign client and a shared database per service pattern.

You can design extensible object-oriented systems using SOLID principles and classic design patterns.

1. What 'design' really means for code90 min
   • maintainability vs quick hacks
   • handling changing requirements
   • code smells and refactoring
2. Object-oriented thinking90 min
   • encapsulation of behavior
   • composition over inheritance
   • managing object dependencies
3. SOLID principles in plain English90 min
   • Single Responsibility and Open-Closed
   • Liskov Substitution and Interface Segregation
   • Dependency Inversion principle
4. Common design patterns90 min
   • creational patterns (Factory, Singleton)
   • structural patterns (Adapter, Decorator)
   • behavioral patterns (Strategy, Observer)
5. UML and modelling a problem90 min
   • class diagrams
   • sequence diagrams
   • identifying entities and methods
6. Designing a real object model (e.g., a booking or parking system)90 min
   • requirements clarification
   • class hierarchy design
   • concurrency considerations in LLD

Hands-on project: Design and implement a multi-threaded parking lot or movie ticket booking system in Java applying strategy, factory, and singleton design patterns.

You can design large-scale distributed systems balancing scalability, consistency, and availability.

1. The building blocks: servers, databases, caches, queues90 min
   • DNS and reverse proxies
   • SQL vs NoSQL trade-offs
   • cache invalidation strategies
2. Load balancing and horizontal scaling90 min
   • round-robin and least-connection algorithms
   • health checks
   • stateless application servers
3. Database replication and sharding90 min
   • master-slave replication lag
   • horizontal sharding keys
   • consistent hashing
4. Designing real systems (URL shortener, chat app, news feed)90 min
   • functional and non-functional requirements
   • back-of-the-envelope estimations
   • API design for scale
5. Trade-offs, bottlenecks and reliability90 min
   • CAP theorem in practice
   • single points of failure (SPOF)
   • rate limiting and DDoS mitigation
6. How to answer a system-design interview, step by step90 min
   • structured interview framework
   • driving the conversation
   • defending design choices under cross-examination

Hands-on project: Architect a scalable URL shortener or real-time chat system document complete with load balancer placement, database sharding strategy, and capacity estimation calculations.

You can defend a Java application with tests that run in CI and catch real regressions.

1. The test pyramid in a real app90 min
   • Unit vs slice vs integration
   • @WebMvcTest and @DataJpaTest
   • What not to mock
2. Integration tests on real services90 min
   • Testcontainers
   • Seeding test data
   • Test isolation
3. Testing the front end90 min
   • React Testing Library
   • Queries by role
   • Mocking fetch
4. Quality gates in CI90 min
   • JaCoCo thresholds
   • SonarQube rules
   • Blocking the merge

Hands-on project: Bring the capstone to meaningful coverage: JUnit 5 and Mockito unit tests, an integration test against a Testcontainers database, a React component test, and a CI gate that fails on a coverage drop or a new static-analysis violation.

You can containerize full-stack Java applications with Docker and deploy them to cloud infrastructure.

1. Containerising with Docker90 min
   • Dockerfile best practices
   • multi-stage builds for Java JARs
   • Docker Compose multi-container orchestration
2. CI/CD pipelines90 min
   • GitHub Actions workflow syntax
   • automated build and test stages
   • artifact publishing
3. Deploying to the cloud (AWS)90 min
   • EC2 instance provisioning
   • security groups and inbound rules
   • Nginx reverse proxy and SSL setup
4. Build the full-stack capstone end to end90 min
   • integrating React frontend with Spring Boot backend
   • connecting PostgreSQL database
   • end-to-end integration testing
5. Coding + system-design mock interviews90 min
   • simulated technical interview loops
   • behavioral question preparation
   • feedback and performance review
6. Portfolio, resume and certification90 min
   • GitHub portfolio polish
   • resume engineering for Java roles
   • certificate issuance and career placement guidance

Hands-on project: Containerize the full-stack capstone application with a multi-stage Dockerfile under 150MB, write a docker-compose setup, and deploy it to a live cloud virtual machine.