90-Day Java Engineering Challenge

From OOP fundamentals to production-ready Spring Boot microservices. Check off each day as you complete it.

---

Progress Tracker

Phase	Topic	Days	Status
1	Java OOP Foundations	1–30
2	Advanced Java & Lambdas	31–60
3	Spring Boot & Microservices	61–90
+	Kafka, Grafana, Docker, Kubernetes	Bonus

---

Phase 1 — Java OOP Foundations (Days 1–30)

Week 1 — Environment & Language Basics

• Day 1 — Install JDK 21, set up IntelliJ IDEA / VS Code, write and run your first Hello, World! program, understand javac and java commands
• Day 2 — Primitive types (int, long, double, boolean, char), type casting, literals, and the difference between stack and heap memory
• Day 3 — Variables, constants (final), naming conventions, String basics (length, charAt, substring, equals, contains)
• Day 4 — Operators: arithmetic, comparison, logical, bitwise, ternary; operator precedence rules
• Day 5 — Control flow: if, else if, else, nested conditions, switch statements and switch expressions (Java 14+)
• Day 6 — Loops: for, while, do-while; loop control with break, continue, and labelled loops
• Day 7 — Methods: declaration, parameters, return types, void, method signatures; build a small calculator utility class

Week 2 — OOP Core Concepts

• Day 8 — Classes and objects: defining a class, creating instances with new, instance vs. class members
• Day 9 — Constructors: default, parameterised, constructor chaining with this(); understand object lifecycle
• Day 10 — Encapsulation: private fields, public getters/setters, data hiding, and why it matters
• Day 11 — Access modifiers in depth: public, protected, private, package-private; design boundaries
• Day 12 — The static keyword: static fields, static methods, static initialiser blocks, Math and Arrays utility classes
• Day 13 — Inheritance: extends, method inheritance, the super keyword for fields and constructors
• Day 14 — Method overriding: @Override, dynamic dispatch, covariant return types; build an Animal hierarchy

Week 3 — Polymorphism, Abstraction & Interfaces

• Day 15 — Polymorphism: compile-time (overloading) vs. runtime (overriding); upcasting and downcasting
• Day 16 — instanceof check (and pattern matching instanceof in Java 16+); safe casting practices
• Day 17 — Abstract classes: abstract keyword, abstract methods, when to use abstract class vs. concrete class
• Day 18 — Interfaces: defining interfaces, implements, default methods (Java 8+), static interface methods
• Day 19 — Multiple interface implementation, interface segregation, marker interfaces; compare abstract class vs. interface
• Day 20 — Inner classes: static nested, inner (non-static), local, anonymous classes; use-cases for each
• Day 21 — Enums: defining enums, adding fields and methods to enums, EnumSet, EnumMap

Week 4 — Core Java Utilities & Project

• Day 22 — String deep-dive: immutability, String pool, StringBuilder vs StringBuffer, common String methods
• Day 23 — Arrays: declaration, initialisation, multi-dimensional arrays, Arrays utility (sort, binarySearch, copyOf)
• Day 24 — Wrapper classes: Integer, Double, etc.; autoboxing and unboxing; Integer.parseInt, valueOf
• Day 25 — java.util.Objects: requireNonNull, toString, hash; equals and hashCode contract
• Day 26 — Packages and imports: organising code, import static, Java module system overview (JPMS)
• Day 27 — Intro to ArrayList and LinkedList: when to use which, common operations, iteration
• Day 28 — Intro to HashMap and HashSet: key-value storage, equals/hashCode importance, collision basics
• Day 29 — OOP design principles: SOLID (Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion)
• Day 30 — Phase 1 Project: Design and implement a Library Management System using OOP: Book, Member, Loan, and LibraryService classes with full encapsulation

---

Phase 2 — Advanced Java & Lambdas (Days 31–60)

Week 5 — Collections Framework

• Day 31 — Collections hierarchy: Collection, List, Set, Queue, Deque; choosing the right structure
• Day 32 — ArrayList vs LinkedList internals, Vector, Stack; time complexity comparison
• Day 33 — HashSet, LinkedHashSet, TreeSet; NavigableSet operations, ordering and uniqueness
• Day 34 — HashMap internals (buckets, load factor, rehashing), LinkedHashMap, TreeMap
• Day 35 — PriorityQueue, ArrayDeque; implementing a task scheduler with a priority queue
• Day 36 — Collections utility class: sort, shuffle, unmodifiableList, synchronizedList; Comparable vs Comparator

Week 6 — Generics & Exception Handling

• Day 37 — Generics basics: generic classes, generic methods, type parameters <T>, <K,V>
• Day 38 — Bounded type parameters: <T extends Comparable<T>>, wildcards <?>, <? extends T>, <? super T>
• Day 39 — Type erasure, raw types, heap pollution; write a generic Pair<A,B> and Stack<T> implementation
• Day 40 — Exception hierarchy: Throwable, Error, Exception, checked vs. unchecked; try-catch-finally
• Day 41 — Multi-catch (|), try-with-resources (AutoCloseable), suppressed exceptions
• Day 42 — Custom exceptions: creating checked and unchecked exceptions, best practices for exception messages and chaining

Week 7 — I/O, Concurrency Basics

• Day 43 — java.io: File, FileReader, FileWriter, BufferedReader, BufferedWriter; reading and writing text files
• Day 44 — java.nio.file: Path, Paths, Files; file walking with Files.walk, copying, moving, deleting
• Day 45 — Serialisation: Serializable, ObjectOutputStream, ObjectInputStream, transient keyword
• Day 46 — Threads: Thread class, Runnable, Callable; start() vs run(); thread states and lifecycle
• Day 47 — Synchronisation: synchronized blocks and methods, volatile, deadlock prevention, wait/notify
• Day 48 — java.util.concurrent: ExecutorService, Executors, Future, CompletableFuture basics

Week 8 — Functional Programming & Lambdas

• Day 49 — Functional interfaces: @FunctionalInterface, Function<T,R>, Predicate<T>, Consumer<T>, Supplier<T>, BiFunction
• Day 50 — Lambda expressions: syntax, variable capture, effectively final, method references (::)
• Day 51 — Function composition: andThen, compose; Predicate composition: and, or, negate
• Day 52 — Streams API: stream(), filter, map, flatMap, distinct, sorted, limit, skip
• Day 53 — Stream terminal operations: collect, forEach, reduce, count, findFirst, anyMatch, allMatch
• Day 54 — Collectors: toList, toSet, toMap, groupingBy, partitioningBy, joining, counting
• Day 55 — Optional<T>: of, ofNullable, isPresent, ifPresent, orElse, orElseGet, map, flatMap, filter
• Day 56 — Parallel streams: when to use, fork/join framework, thread safety with parallel streams, performance pitfalls
• Day 57 — CompletableFuture deep-dive: thenApply, thenAccept, thenCompose, allOf, anyOf, exception handling

Week 9 — Modern Java & Design Patterns

• Day 58 — Records (Java 16+): immutable data carriers, compact constructors, with-pattern workaround
• Day 59 — Sealed classes (Java 17+), pattern matching in switch (Java 21+), text blocks
• Day 60 — Phase 2 Project: Rewrite the Library Management System using Streams, Lambdas, Optional, and Records; add concurrent book reservation with CompletableFuture

---

Phase 3 — Spring Boot & Microservices (Days 61–90)

Week 10 — Spring Core & IoC

• Day 61 — Spring Framework overview: IoC container, ApplicationContext, Spring vs Spring Boot; set up a Maven/Gradle Spring Boot project via start.spring.io
• Day 62 — Dependency Injection: @Component, @Service, @Repository, @Controller; constructor injection vs field injection
• Day 63 — Spring configuration: @Configuration, @Bean, @Value, application.properties / application.yml; profiles with @Profile
• Day 64 — Spring Boot auto-configuration: @SpringBootApplication, @EnableAutoConfiguration, starter dependencies, how Spring Boot wires itself

Week 11 — Building REST APIs

• Day 65 — REST fundamentals: HTTP verbs (GET, POST, PUT, PATCH, DELETE), status codes, request/response bodies, REST constraints
• Day 66 — @RestController, @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping; path variables and query params
• Day 67 — Request body binding: @RequestBody, @RequestParam, @PathVariable; Jackson JSON serialisation / deserialisation
• Day 68 — Response entities: ResponseEntity<T>, custom HTTP status codes, response headers
• Day 69 — Input validation: @Valid, Bean Validation annotations (@NotNull, @Size, @Email, @Pattern), BindingResult, global exception handler with @ControllerAdvice

Week 12 — Persistence with Spring Data JPA

• Day 70 — JPA basics: entities, @Entity, @Id, @GeneratedValue, @Column; H2 in-memory database setup
• Day 71 — Spring Data JPA repositories: JpaRepository, CrudRepository; derived query methods (findByName, findByEmailAndStatus)
• Day 72 — JPQL and @Query; @Modifying, pagination with Pageable, sorting with Sort
• Day 73 — Relationships: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany; fetch types (LAZY vs EAGER), cascading
• Day 74 — Transactions: @Transactional, isolation levels, propagation behaviour; optimistic locking with @Version
• Day 75 — Flyway / Liquibase database migrations; connect to PostgreSQL, configure DataSource

Week 13 — Security & Testing

• Day 76 — Spring Security basics: SecurityFilterChain, HttpSecurity, in-memory UserDetailsService, password encoding with BCryptPasswordEncoder
• Day 77 — JWT authentication: issue and validate tokens, OncePerRequestFilter, stateless sessions; role-based access with @PreAuthorize
• Day 78 — Unit testing with JUnit 5: @Test, @BeforeEach, @AfterEach, @ParameterizedTest, assertions with AssertJ
• Day 79 — Mocking with Mockito: @Mock, @InjectMocks, when/thenReturn, verify, argument captors; test service layers in isolation
• Day 80 — Integration testing: @SpringBootTest, @WebMvcTest, MockMvc, @DataJpaTest with Testcontainers

Week 14 — Microservices & Production Readiness

• Day 81 — Actuator: spring-boot-actuator, health, metrics, info endpoints; custom health indicators
• Day 82 — Microservices architecture: decomposition patterns, bounded contexts, inter-service communication (REST vs messaging)
• Day 83 — Spring Cloud basics: spring-cloud-config for centralised configuration, @RefreshScope
• Day 84 — Service discovery with Eureka: @EnableEurekaServer, @EnableEurekaClient, client-side load balancing with Spring Cloud LoadBalancer
• Day 85 — API Gateway with Spring Cloud Gateway: routing, filters, rate limiting, circuit breaker pattern with Resilience4j
• Day 86 — RestTemplate vs WebClient for inter-service HTTP calls; reactive programming introduction with Project Reactor (Mono, Flux)
• Day 87 — Application observability: distributed tracing with Micrometer + Zipkin, structured logging with Logback / Logstash encoder
• Day 88 — Caching: @Cacheable, @CacheEvict, @CachePut; Redis integration with Spring Data Redis
• Day 89 — API documentation: OpenAPI 3 / Swagger UI with springdoc-openapi; versioning strategies
• Day 90 — Phase 3 Capstone: Build a fully functional E-Commerce Order Service microservice — REST API, JPA persistence (PostgreSQL), JWT security, unit + integration tests, Actuator health endpoints, and OpenAPI docs

---

Extra — Cloud-Native & Observability Stack

Complete these after the 90-day core to become production-ready.

Apache Kafka

• Kafka 1 — Core concepts: topics, partitions, offsets, producers, consumers, consumer groups, brokers, ZooKeeper vs KRaft
• Kafka 2 — Run Kafka locally with Docker Compose; use kafka-topics.sh, kafka-console-producer, kafka-console-consumer
• Kafka 3 — Spring Kafka: @KafkaListener, KafkaTemplate, @EnableKafka; configure serialisers/deserialisers with Avro or JSON
• Kafka 4 — Consumer group rebalancing, offset management (auto.offset.reset), manual acknowledgement (AckMode)
• Kafka 5 — Error handling: dead-letter topics, SeekToCurrentErrorHandler, retry logic with BackOff
• Kafka 6 — Kafka Streams basics: StreamsBuilder, KStream, KTable, stateful operations (groupByKey, count, aggregate)
• Kafka 7 — Connect a Kafka producer in the Order Service from the capstone; emit OrderPlaced events and consume them in a NotificationService

Grafana & Observability

• Grafana 1 — Observability pillars: metrics, logs, traces; install the LGTM stack (Loki, Grafana, Tempo, Mimir) via Docker Compose
• Grafana 2 — Prometheus: scrape configuration, metric types (counter, gauge, histogram, summary), promtool, PromQL basics
• Grafana 3 — Expose Micrometer metrics from Spring Boot to Prometheus; add custom Counter and Timer beans
• Grafana 4 — Grafana dashboards: add Prometheus data source, build a JVM dashboard (heap, GC, thread count, HTTP request rate)
• Grafana 5 — Grafana Loki: ship Spring Boot logs via Promtail or Loki4j appender, query logs with LogQL
• Grafana 6 — Distributed tracing: wire Tempo into Grafana, correlate traces from Zipkin/OTLP with Micrometer Tracing
• Grafana 7 — Alerting: configure Grafana alert rules, contact points (email / Slack), notification policies, and silences

Docker

• Docker 1 — Docker fundamentals: images, containers, layers, docker run, docker ps, docker stop, docker rm
• Docker 2 — Write a Dockerfile for a Spring Boot JAR: multi-stage build (builder + runtime stage), non-root user, EXPOSE
• Docker 3 — docker build, docker tag, docker push to Docker Hub; understand image caching and layer ordering for faster builds
• Docker 4 — Docker Compose: compose.yml, services, networks, volumes; spin up Spring Boot + PostgreSQL + Kafka together
• Docker 5 — Docker Compose health checks, depends_on with condition: service_healthy, environment variable injection from .env
• Docker 6 — Docker volumes and networking: bridge vs host vs none networks, named volumes vs bind mounts, docker inspect
• Docker 7 — Docker best practices: .dockerignore, minimal base images (eclipse-temurin:21-jre-alpine), image scanning with docker scout

Kubernetes

• K8s 1 — Kubernetes architecture: control plane (API server, etcd, scheduler, controller manager), worker nodes (kubelet, kube-proxy, container runtime)
• K8s 2 — Set up a local cluster with minikube or kind; explore kubectl basics: get, describe, apply, delete, logs, exec
• K8s 3 — Core objects: Pod, ReplicaSet, Deployment; write a Deployment YAML for the Order Service and apply it
• K8s 4 — Services: ClusterIP, NodePort, LoadBalancer; expose the Order Service with a NodePort service locally
• K8s 5 — ConfigMap and Secret: externalise application config and DB credentials; mount as environment variables and volume files
• K8s 6 — Persistent storage: PersistentVolume, PersistentVolumeClaim; mount a volume for PostgreSQL data
• K8s 7 — Ingress: install nginx-ingress-controller, define Ingress rules, path-based and host-based routing
• K8s 8 — Health probes: livenessProbe, readinessProbe, startupProbe; configure them using the Actuator /health endpoint
• K8s 9 — Resource management: requests and limits (CPU/memory), HorizontalPodAutoscaler based on CPU utilisation
• K8s 10 — Rolling deployments and rollbacks: RollingUpdate strategy, kubectl rollout status, kubectl rollout undo
• K8s 11 — Helm: install Helm, helm create a chart for the Order Service, helm install, helm upgrade, values.yaml overrides
• K8s 12 — Final Challenge: Deploy the full capstone stack (Order Service, PostgreSQL, Kafka, Prometheus, Grafana) to Kubernetes using Helm charts; configure Ingress, autoscaling, and Grafana dashboards end-to-end

---

Resources

Topic	Resource
Java	docs.oracle.com/en/java/javase/21
Spring Boot	spring.io/guides
Kafka	kafka.apache.org/documentation
Grafana	grafana.com/docs
Docker	docs.docker.com
Kubernetes	kubernetes.io/docs
Practice	exercism.org/tracks/java

---

Start date: ___________ | Target completion: ___________