# Java Developer Roadmap 2026

> A free, experience-based learning path from Java Trendz, a Java training institute in Indore, India: Core Java → SQL → Spring Boot → Microservices → Cloud → DevOps → AI, with what to learn as a fresher and at 1–2, 3–5 and 5+ years of experience.

Interactive version with progress tracking: https://www.javatrendz.com/java-developer-roadmap

How to read it: every topic is tagged with the experience level at which it is usually expected. A developer at a given level should already know everything tagged with earlier levels.

## Experience levels

### Fresher — Get job-ready

Strong fundamentals and one project you can explain end to end, line by line.

What you own at this level:
- Writing correct code for well-defined tasks
- Fixing bugs with guidance from seniors
- Following the team’s Git and code review process

What interviews focus on:
- Core Java and OOP
- Collections and Java 8 streams
- SQL queries and joins
- Basic DSA: arrays, strings, hashing
- A walkthrough of your own project

### 1–2 years — Own features end to end

Go from “it works on my machine” to code that is tested, secured and deployed.

What you own at this level:
- Delivering features from ticket to production
- Writing tests with every change
- Debugging issues in shared environments

What interviews focus on:
- Spring Boot internals and REST design
- JPA pitfalls: N+1, lazy loading
- Transactions and indexes
- Multithreading basics
- How you test your code
- DSA: medium-level problems

### 3–5 years — Own services and design

Design components, keep them reliable under load, and help juniors grow.

What you own at this level:
- Designing services and their APIs
- Production reliability and on-call
- Code review and mentoring

What interviews focus on:
- Low-level and high-level system design
- Concurrency and JVM performance
- Saga, outbox, circuit breaker
- Kafka and event-driven design
- Real production incident stories

### 5+ years — Own architecture and direction

Make trade-offs that still hold up in three years, and raise the bar for the whole team.

What you own at this level:
- Architecture decisions and their trade-offs
- Technical direction across teams
- Hiring, mentoring and engineering standards

What interviews focus on:
- Architecture trade-offs, with numbers
- Scalability, availability and cost
- Migrations: monolith to services, on-prem to cloud
- Leadership and disagreement scenarios
- Security and compliance thinking

## The path

### 1. Core Java

The language, the JDK and the habits every later stage builds on.

#### Fresher

- **Syntax, data types & control flow** — Primitives vs wrappers, operators, loops, switch.
- **OOP: classes, inheritance, polymorphism** — Plus abstraction, encapsulation and interfaces.
- **Strings & immutability** — String pool, StringBuilder, why immutability matters.
- **Exception handling** — Checked vs unchecked, try-with-resources, custom exceptions.
- **Collections Framework** — List, Set, Map — and the equals/hashCode contract.
- **Generics** — Type parameters, bounded types, wildcards.
- **Java 8: lambdas & Streams API** — map / filter / reduce, collectors, method references.
- **Git basics** — Commit, branch, merge, pull request.
- **Maven or Gradle basics** — Dependencies, build lifecycle, running tests.
- **JUnit 5 basics** — No feature is done until a test proves it.
- **DSA fundamentals** — Arrays, strings, hashing, recursion, sorting, Big-O.

#### 1–2 years

- **Modern Java (17 → 21 → 25 LTS)** — Records, sealed types, pattern matching, text blocks.
- **Multithreading & ExecutorService** — Thread pools, Callable/Future, CompletableFuture.
- **Unit testing with Mockito** — Mocks vs stubs; test behaviour, not implementation.
- **Clean code & SOLID** — Naming, small methods, dependency direction.
- **Logging with SLF4J + Logback** — Levels, structured logs, never logging secrets.

#### 3–5 years

- **JVM internals** — Heap, stack, metaspace, class loading, JIT.
- **Garbage collection & tuning** — G1 vs ZGC, reading GC logs, fixing memory leaks.
- **Concurrency deep dive** — Locks, atomics, java.util.concurrent, happens-before.
- **Virtual threads (Project Loom)** — When they help — and when pinning hurts.
- **Design patterns in practice** — Strategy, factory, builder, observer — without over-engineering.
- **Profiling with JFR & async-profiler** — Find the real hotspot before optimising anything.

#### 5+ years

- **Performance engineering** — Latency budgets, load testing, capacity planning.
- **Container-aware JVM tuning** — Heap sizing and GC choice inside Kubernetes limits.
- **API & library design** — Backward compatibility, versioning, deprecation policy.
- **Setting team coding standards** — Review culture, static analysis, mentoring.

Tools used in this stage: IntelliJ IDEA (Fresher), Maven (Fresher), Gradle (1–2 years), JUnit 5 (Fresher), Mockito (1–2 years).

### 2. SQL & Databases

Most production bugs are data bugs. Learn to model, query and tune.

#### Fresher

- **SQL fundamentals** — SELECT, WHERE, ORDER BY, GROUP BY, HAVING.
- **Joins** — Inner, left, right and self joins — and when each is right.
- **Keys & constraints** — Primary, foreign, unique, not null.
- **Normalisation (1NF–3NF)** — Design tables that never contradict themselves.
- **JDBC basics** — Connections, PreparedStatement, why never to concatenate SQL.

#### 1–2 years

- **Indexes & EXPLAIN plans** — Read a query plan and spot a full table scan.
- **Transactions & isolation levels** — ACID, dirty and phantom reads, picking a level.
- **JPA / Hibernate** — Entity mapping, lazy vs eager, the N+1 problem.
- **Schema migrations (Flyway / Liquibase)** — Versioned, reviewable database changes.
- **Window functions & CTEs** — Rankings, running totals, readable complex queries.

#### 3–5 years

- **Query tuning at scale** — Composite and covering indexes, batch writes.
- **Connection pooling (HikariCP)** — Pool sizing, timeouts, leak detection.
- **Caching with Redis** — Cache-aside, TTLs, invalidation strategies.
- **NoSQL: MongoDB and when to use it** — Document modelling vs relational trade-offs.
- **Optimistic vs pessimistic locking** — @Version, SELECT … FOR UPDATE, lost updates.

#### 5+ years

- **Partitioning, sharding & read replicas** — Scaling reads and writes past one server.
- **Consistency trade-offs (CAP, PACELC)** — Choosing what to give up, deliberately.
- **Choosing the right datastore** — Postgres, MongoDB, Cassandra, Elasticsearch — by access pattern.
- **Zero-downtime migrations** — Expand/contract changes on live tables.

Tools used in this stage: MySQL (Fresher), PostgreSQL (Fresher), Hibernate (1–2 years), Flyway (1–2 years), Redis (3–5 years), MongoDB (3–5 years), Elasticsearch (5+ years).

### 3. Spring Boot

The framework most Java job descriptions actually ask for.

#### Fresher

- **Spring core: IoC & dependency injection** — Beans, scopes, @Component vs @Bean.
- **Auto-configuration & starters** — What Boot does for you, and how to inspect it.
- **Building REST APIs** — Controllers, DTOs, status codes, validation.
- **Spring Data JPA basics** — Repositories, derived queries, paging.
- **Configuration & profiles** — application.yml and environment-specific settings.

#### 1–2 years

- **Global exception handling** — @ControllerAdvice and consistent error responses.
- **Spring Security + JWT** — Authentication, authorisation, password hashing.
- **Testing Spring apps** — @WebMvcTest, @DataJpaTest, Testcontainers.
- **API documentation with OpenAPI** — Swagger UI generated from your code.
- **Actuator & health checks** — Metrics and readiness for production.

#### 3–5 years

- **OAuth2 & OpenID Connect** — Resource servers, Keycloak, token flows.
- **Transactions in depth** — Propagation, rollback rules, self-invocation pitfalls.
- **Caching, async & scheduling** — @Cacheable, @Async and @Scheduled, done safely.
- **Spring AOP** — Cross-cutting concerns without copy-paste.
- **Reactive Spring (WebFlux)** — Know when non-blocking actually pays off.

#### 5+ years

- **Custom starters & auto-configuration** — Package team conventions as reusable modules.
- **Hexagonal / clean architecture** — Keep the domain independent of the framework.
- **Major-version upgrades** — javax → jakarta, Boot 2 → 3 → 4: planned, not panicked.

Tools used in this stage: Postman (Fresher), Testcontainers (1–2 years), Spring Boot (Fresher), Spring Security (1–2 years), OpenAPI / Swagger (1–2 years), Keycloak (3–5 years).

### 4. Microservices

Splitting systems into services — and handling everything that breaks when you do.

#### Fresher

- **Monolith vs microservices** — Concepts only: why teams split, and what it costs.
- **HTTP & REST principles** — Methods, status codes, idempotency, JSON.

#### 1–2 years

- **Service-to-service calls** — RestClient, WebClient, OpenFeign.
- **Spring Cloud essentials** — Config server, service discovery, API gateway.
- **Messaging basics: Kafka / RabbitMQ** — Producers, consumers, topics and queues.
- **API design & versioning** — Backward-compatible changes, pagination, error format.

#### 3–5 years

- **Resilience patterns** — Circuit breaker, retry, timeout, bulkhead (Resilience4j).
- **Kafka in depth** — Partitions, consumer groups, ordering, exactly-once.
- **Saga & outbox patterns** — Consistency without distributed transactions.
- **Distributed tracing** — OpenTelemetry and trace IDs across services.
- **Contract testing** — Catch breaking API changes before they deploy.

#### 5+ years

- **Domain-Driven Design** — Bounded contexts decide your service boundaries.
- **Event-driven architecture & CQRS** — When events simplify — and when they complicate.
- **Monolith decomposition** — Strangler-fig migrations, no big-bang rewrite.
- **System design at scale** — Availability, latency, throughput — with numbers.

Tools used in this stage: Apache Kafka (1–2 years), RabbitMQ (1–2 years), OpenTelemetry (3–5 years).

### 5. Cloud

Where your code actually runs. Learn one provider properly.

#### Fresher

- **Cloud fundamentals** — IaaS vs PaaS vs SaaS, regions, availability zones.
- **Deploy one app publicly** — A live URL on your CV beats a localhost screenshot.

#### 1–2 years

- **Core services: compute, storage, IAM** — EC2, S3, RDS, IAM — or the Azure/GCP equivalents.
- **Secrets & configuration** — Keep credentials out of code and Git history.
- **Managed databases** — Backups, snapshots, parameter tuning.

#### 3–5 years

- **Networking: VPC & load balancers** — Subnets, security groups, private services.
- **Serverless & managed messaging** — Lambda, SQS/SNS — when not to run servers at all.
- **Infrastructure as Code (Terraform)** — Reviewable, repeatable environments.
- **Cost awareness** — Tagging, right-sizing, reading the bill.

#### 5+ years

- **Well-Architected design** — Reliability, security, cost and performance pillars.
- **High availability & disaster recovery** — Multi-AZ, RTO/RPO, restores you have actually tested.
- **Cloud security & compliance** — Least privilege, encryption, audit trails.
- **Multi-cloud & hybrid trade-offs** — Portability vs using managed services well.

Tools used in this stage: AWS (1–2 years), Microsoft Azure (3–5 years), Google Cloud (3–5 years), Terraform (3–5 years).

### 6. DevOps

Ship safely and often: containers, pipelines and production visibility.

#### Fresher

- **Linux command line** — Files, processes, permissions, reading logs over SSH.
- **Git workflow in a team** — Branching strategy, pull requests, resolving conflicts.

#### 1–2 years

- **Docker** — Dockerfile, images, layers, Docker Compose.
- **CI pipelines** — GitHub Actions or Jenkins: build, test, package on every push.
- **Code quality gates** — SonarQube, coverage thresholds, dependency checks.
- **Shell scripting** — Automate the repetitive deploy and ops tasks.

#### 3–5 years

- **Kubernetes** — Pods, deployments, services, ConfigMaps, probes.
- **Helm & CD to Kubernetes** — Versioned releases and one-command rollbacks.
- **Observability** — Prometheus metrics, Grafana dashboards, central logs.
- **Deployment strategies** — Rolling, blue-green, canary.

#### 5+ years

- **GitOps with Argo CD** — Git as the source of truth for what runs.
- **SRE practices** — SLOs, error budgets, blameless incident reviews.
- **DevSecOps** — Image scanning, SBOMs, supply-chain security.
- **Platform engineering** — Golden paths so every team ships the same safe way.

Tools used in this stage: Git (Fresher), GitHub (Fresher), Jira (Fresher), Trivy (5+ years), Docker (1–2 years), Kubernetes (3–5 years), Helm (3–5 years), GitHub Actions (1–2 years), Jenkins (1–2 years), SonarQube (1–2 years), Argo CD (5+ years), Prometheus (3–5 years), Grafana (3–5 years), Linux (Fresher).

### 7. AI for Java Developers

Use AI to code faster — then build AI features into Java applications.

#### Fresher

- **AI coding assistants, used responsibly** — Copilot, Claude, ChatGPT — and reviewing every line they write.
- **Prompting for developers** — Give context, constraints and examples; verify the output.

#### 1–2 years

- **Calling LLM APIs from Java** — REST calls, streaming responses, keys handled safely.
- **Spring AI basics** — ChatClient, prompt templates, structured output.

#### 3–5 years

- **RAG with embeddings** — Vector stores such as pgvector, chunking, retrieval quality.
- **Tool calling & MCP** — Let models call your Java services — safely.
- **LangChain4j** — A Java-native AI toolkit worth knowing alongside Spring AI.
- **Testing & evaluating AI features** — Evals, golden datasets, regression checks.

#### 5+ years

- **AI system design** — Latency, cost, fallbacks and caching for LLM features.
- **AI security** — Prompt injection, data leakage, access control.
- **Leading AI adoption** — Policies, reviews and measuring real productivity gains.

Tools used in this stage: GitHub Copilot (Fresher), Claude (Fresher), ChatGPT (Fresher), Spring AI (1–2 years), LangChain4j (3–5 years), pgvector (3–5 years), Ollama (3–5 years).

## Tools and technologies by experience level

### Fresher

- **IntelliJ IDEA** (Build & IDE) — The IDE most Java teams use — learn its debugger and refactorings.
- **Maven** (Build & IDE) — The default build tool in most enterprise Java codebases.
- **Git** (Collaboration) — Version control is non-negotiable from day one.
- **GitHub** (Collaboration) — Pull requests, code review — and your public portfolio.
- **Jira** (Collaboration) — How most teams plan sprints and track tickets.
- **JUnit 5** (Testing) — The standard Java testing framework.
- **Postman** (Testing) — Explore and test APIs by hand before you automate.
- **MySQL** (Data) — The most common first relational database.
- **PostgreSQL** (Data) — Feature-rich SQL database, the default for many new services.
- **Spring Boot** (Frameworks) — The framework Java job postings ask for most.
- **Linux** (Cloud & Ops) — Servers run Linux — you will SSH into one sooner than you think.
- **GitHub Copilot** (AI) — AI pair programmer inside your IDE.
- **Claude** (AI) — AI assistant for reasoning through code, bugs and design.
- **ChatGPT** (AI) — General-purpose AI assistant for explanations and drafts.

### 1–2 years

- **Gradle** (Build & IDE) — Faster, scriptable builds; common in newer projects.
- **Mockito** (Testing) — Isolate the unit under test with mocks and stubs.
- **Testcontainers** (Testing) — Real databases and brokers inside integration tests.
- **Hibernate** (Data) — The JPA implementation underneath Spring Data JPA.
- **Flyway** (Data) — Versioned SQL migrations that live in Git.
- **Spring Security** (Frameworks) — Authentication and authorisation for Spring apps.
- **OpenAPI / Swagger** (Frameworks) — Document and share your API contract.
- **Apache Kafka** (Messaging) — The event-streaming backbone of many microservice systems.
- **RabbitMQ** (Messaging) — Classic message broker for queues and routing.
- **Docker** (Containers) — Package your app with everything it needs to run.
- **GitHub Actions** (CI/CD) — CI/CD that lives right next to your code.
- **Jenkins** (CI/CD) — Still everywhere in enterprise pipelines.
- **SonarQube** (CI/CD) — Static analysis and quality gates on every build.
- **AWS** (Cloud & Ops) — A widely used cloud and a safe first provider to learn.
- **Spring AI** (AI) — Spring’s own way to call LLMs, embeddings and vector stores.

### 3–5 years

- **Redis** (Data) — Caching, rate limiting and fast key-value storage.
- **MongoDB** (Data) — Document database for flexible, nested data.
- **Keycloak** (Security) — Open-source identity provider for OAuth2 and OIDC.
- **Kubernetes** (Containers) — Run, heal and scale containers in production.
- **Helm** (Containers) — Package and version Kubernetes deployments.
- **Prometheus** (Observability) — Metrics collection and alerting.
- **Grafana** (Observability) — Dashboards for metrics, logs and traces.
- **OpenTelemetry** (Observability) — Vendor-neutral traces, metrics and logs.
- **Microsoft Azure** (Cloud & Ops) — Common in enterprises already built on Microsoft.
- **Google Cloud** (Cloud & Ops) — Strong in data platforms and managed Kubernetes.
- **Terraform** (Cloud & Ops) — Infrastructure as code across every major provider.
- **LangChain4j** (AI) — Java-native toolkit for LLM apps, agents and RAG.
- **pgvector** (AI) — Vector search inside PostgreSQL for RAG.
- **Ollama** (AI) — Run open models locally for private experiments.

### 5+ years

- **Elasticsearch** (Data) — Full-text search and log analytics at scale.
- **Trivy** (Security) — Scan images and dependencies for known vulnerabilities.
- **Argo CD** (CI/CD) — GitOps continuous delivery for Kubernetes.

## Frequently asked questions

### How long does it take to become a job-ready Java developer?

With steady daily practice, most freshers reach job-ready fundamentals — Core Java, SQL, Spring Boot basics and one deployed project — in six to nine months. The later stages of this roadmap are learned on the job, over years.

### Should I learn microservices before my first job?

Understand the concepts, but put your energy into one solid Spring Boot application with tests and a real database. Fresher interviews lean heavily on Core Java, SQL and how well you can explain your own project.

### Which cloud should a Java developer learn first?

AWS is a safe default because it is so widely used, and the concepts carry over to Azure and Google Cloud. Learn one provider properly rather than three superficially.

### Do Java developers need to learn AI in 2026?

Everyone benefits from using AI assistants well — and reviewing what they produce. Building AI features with Spring AI, RAG and tool calling is fast becoming a differentiator for developers with one to five years of experience.

---

Source: Java Trendz, https://www.javatrendz.com. Free to read, share and reference with attribution.