What a Junior } should know

Understands basic algorithmic concepts in Java: simple Stream operations, basic sorting and searching in collections, loop-based algorithms for data processing. Follows team guidance on algorithm selection and applies standard Java Collections Framework operations.

Understands basic async programming in Java: CompletableFuture basics, @Async annotations in Spring, simple callback patterns. Follows team conventions for async method design and understands basic Future composition.

Understands basic code quality principles for Java/Spring development. Follows team coding standards and Checkstyle/PMD rules. Writes simple, clean methods following Java naming conventions and Spring patterns. Accepts code review feedback and applies SOLID principles in basic implementations.

Understands basic Java collection types: ArrayList, HashMap, HashSet for common operations. Follows team conventions for entity classes and DTO structures. Applies simple data structures for CRUD operations and Spring controller request/response handling.

Understands basic design patterns in Java: Singleton, Factory Method, Builder pattern, Observer in event handling, dependency injection with Spring IoC container. Follows team conventions for pattern usage in Spring Boot applications.

Understands Java generics fundamentals: declares generic classes and methods with type parameters, uses bounded type parameters (extends/super). Aware of type erasure and its implications — cannot instantiate T or use instanceof with generic types. Correctly applies generic collections (List<String>, Map<K,V>) and avoids raw types in new code.

Understands basic multithreading in Java: Thread and Runnable basics, synchronized keyword and basic locking, ExecutorService for thread pool management, understanding of volatile and happens-before guarantees. Follows team conventions for concurrent code in Spring applications.

Understands basic OOP concepts in Java: classes, interfaces, abstract classes, encapsulation. Applies simple SOLID principles following Spring project structure. Follows team patterns for service/controller/repository class design and Spring DI annotations.

Understands basics of Java type system — generics, bounded type parameters, and Optional for null safety. Follows team conventions for type-safe collections, enum patterns, and interface-based dependency injection with proper type hierarchies.

Understands Kafka fundamentals for Java services: Spring Kafka producer/consumer setup, topic/partition concepts, and message serialization with Avro/JSON. Follows team practices for consumer group configuration and basic error handling in message processing.

Understands why caching is needed in Java applications. Applies Spring Cache abstraction: @Cacheable for read-heavy operations. Invalidates cache on data updates. Knows the difference between local and distributed cache.

Uses Elasticsearch / OpenSearch at basic level. Performs simple tasks using ready templates. Understands basic concepts and follows team practices.

Uses Java Spring Ecosystem at basic level. Performs simple tasks using ready templates. Understands basic concepts and follows team practices.

Works with RabbitMQ via Spring AMQP: sends messages to exchange, listens to queues via @RabbitListener. Understands exchange types (direct, topic, fanout). Handles errors through retry and DLQ.

Uses Redis via Spring Data Redis for caching: @Cacheable, @CacheEvict, @CachePut. Works with strings, hashes, lists. Understands TTL and eviction policies. Configures RedisTemplate with Jackson serializer.

Designs simple data schemas with JPA: Entity, @OneToMany/@ManyToMany relationships, embedded types. Understands normalization. Uses @Enumerated, @Temporal for column typing.

Creates indexes to speed up frequent queries. Understands the difference between B-tree, hash, and GIN indexes. Uses EXPLAIN to verify index usage. Knows about index impact on write speed.

Writes migrations via Flyway/Liquibase: CREATE TABLE, ALTER TABLE, adding indexes and constraints. Understands migration versioning and rollback. Tests migrations on dev environment.

Writes SQL queries for CRUD operations via JPA/Hibernate. Creates tables, indexes, foreign keys. Understands normalization up to 3NF. Uses MySQL Workbench for data analysis.

Works with PostgreSQL via JPA/Hibernate: entity mapping, JPQL queries, native queries. Uses pgAdmin for data and schema analysis. Understands PostgreSQL data types: UUID, JSONB, arrays.

Understands N+1 problem in JPA and solves via fetch join / @EntityGraph. Uses EXPLAIN ANALYZE for query analysis. Avoids SELECT * and loading unnecessary associations.

Understands ACID properties and isolation levels. Uses @Transactional in Spring for transaction management. Handles deadlocks and optimistic locking via @Version. Knows the difference between read committed and repeatable read.

Documents API via SpringDoc/OpenAPI annotations: @Operation, @ApiResponse, @Schema. Describes parameters, request bodies, and response examples. Keeps Swagger UI up to date.

Understands why API versioning is needed. Works with different versions via URL path (/v1, /v2). Maintains backward compatibility when adding new fields. Knows semantic versioning.

Creates simple GraphQL schemas via Spring for GraphQL: types, queries, mutations. Implements resolvers with @QueryMapping/@MutationMapping. Understands the difference between REST and GraphQL. Tests via GraphiQL.

Creates REST endpoints via Spring MVC: @RestController, @GetMapping/@PostMapping, @RequestBody/@PathVariable. Returns proper HTTP statuses. Validates input via @Valid and Bean Validation.

Understands TCP/IP, DNS, HTTP/HTTPS in Java application context. Configures Spring Boot: server.port, ssl, compression. Diagnoses connection issues. Understands CORS and configures via WebMvcConfigurer.