From your first class to system architect

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

IntelliJ IDEA (Fresher), Maven (Fresher), Gradle (1–2 yrs), JUnit 5 (Fresher), Mockito (1–2 yrs)

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

MySQL (Fresher), PostgreSQL (Fresher), Hibernate (1–2 yrs), Flyway (1–2 yrs), Redis (3–5 yrs), MongoDB (3–5 yrs), Elasticsearch (5+ yrs)

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

Postman (Fresher), Testcontainers (1–2 yrs), Spring Boot (Fresher), Spring Security (1–2 yrs), OpenAPI / Swagger (1–2 yrs), Keycloak (3–5 yrs)

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

Apache Kafka (1–2 yrs), RabbitMQ (1–2 yrs), OpenTelemetry (3–5 yrs)

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

AWS (1–2 yrs), Microsoft Azure (3–5 yrs), Google Cloud (3–5 yrs), Terraform (3–5 yrs)

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

Git (Fresher), GitHub (Fresher), Jira (Fresher), Trivy (5+ yrs), Docker (1–2 yrs), Kubernetes (3–5 yrs), Helm (3–5 yrs), GitHub Actions (1–2 yrs), Jenkins (1–2 yrs), SonarQube (1–2 yrs), Argo CD (5+ yrs), Prometheus (3–5 yrs), Grafana (3–5 yrs), Linux (Fresher)

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

GitHub Copilot (Fresher), Claude (Fresher), ChatGPT (Fresher), Spring AI (1–2 yrs), LangChain4j (3–5 yrs), pgvector (3–5 yrs), Ollama (3–5 yrs)