Java Software Engineer

1) Core Java basics:

* Collections (List, Map, Set) — real use, not just basics

* Concurrent Data Structures for e.g.. ConcurrentHashMap & when to use it

* Java Streams API (Parallel) (map/filter/reduce, collectors)

* Exception handling (e.g.. checked vs unchecked)

* Functional interfaces & lambda expressions

* Immutability & when to apply it

* Basic memory model understanding (heap vs stack)

* Apart from Java 8, any other of the latest versions of Java for eg. Java 11/17 features (any if used)

2) Concurrency:

* ExecutorService / Thread Pools

* CompletableFuture / Parallel execution

* Synchronization & race condition avoidance

* Completable Futures

* Shared resource handling & state management

* Understanding blocking vs non-blocking calls

* When to use volatile vs synchronized (at high level)

3) Spring Boot Microservices:

* Creating REST Controllers & Services, request flow path for a Microservice end to end.

* Using Spring Data JPA/ Hibernate

* Writing Repository layer queries

* Validation (`@Valid`, constraint annotations)

* Global Exception Handling (`@ControllerAdvice`)

* Property management (`application.yml`)

* Feign/WebClient/RestTemplate calls to other services

* API documentation using Swagger/OpenAPI

* Health checks in Spring boot MS/Actuators, basic Tracing/Correlation ID tracking, basics of API gateways.

4) Kafka / Event Driven Systems:

* Producer & Consumer configuration basics of any Pub-Sub mechanism.

* Basic Understanding of consumer groups & partitions

* Basics of Retry handling/error handling & DLQ patterns

* Idempotent processing(avoid duplicates)

* Offsets (auto vs manual commit) — high level

* Event logs debugging

5) Cloud (AWS Preferred):

* EC2 / ECS / EKS OR any compute runtime

* S3 (file storage, triggered workflows)

* CloudWatch (logs and metrics debugging)

* IAM roles/policies (even at basic understanding level)

* Parameter Store / Secrets Manager

* RDS / DynamoDB (any one is fine)

* Basic understanding of VPC/Subnet/Security Groups (tentative)

6) Production Support / Troubleshooting:

* Reading logs to trace failures

* Debugging latency/timeout/db connection issues

* Familiar with thread dumps / heap issues (even high level)

* Rollback / Hotfix experience or basics of these things

* Root cause analysis documentation

* Participation in on-call / incident bridge calls

7) CI/CD Pipeline:

* Using Git (branching -just basic awareness is fine), PR reviews)

* Any Build tool awareness (Maven/Gradle) is fine.

* Any CI/CD Pipline ecosystem awareness-Jenkins/Harness/GitLab pipeline stages (eg. build → test → deploy etc)

* Unit test execution & code coverage gates/tools(Sonar etc)

* Docker image creation basics

* good to have-Basic awarensss of Canary / Rolling / Blue-Green deployment awareness

8)DB basics:

* Writing SQL queries (JOINs, GROUP BY, HAVING, ORDER BY)

* Understanding transaction boundaries (commit, rollback)

* Knowing when to use indexes & how they affect performance

* Familiarity with entity-relationship mapping in Hibernate/JPA

* Familiarity with lazy vs eager loading and knowing why it matters

* Understanding pagination & avoiding full table scans

* Awareness of basic connection pooling (HikariCP / Datasource pools)

* Basics atleast CRUD of any NOSQL DB.