EPAM Interview Experience (Telugu) JAVA Microservices 7 years Interview Rounds Questions Salary

Main Ideas / Concepts Covered (EPAM Palm Java Microservices Interview, ~2025)

Overall Interview Experience (Speaker’s Perspective)

• The interview had 3 rounds for a Java Microservices Developer role.
• The speaker had ~6 years 10 months experience (they mention targeting ~7 years).
• The speaker did not clear the interview, being rejected in Round 3.
• Round timings mentioned:
  • Round 1: ~1 hour
  • Round 2: ~1 hour 30 minutes
  • Round 3: ~1 hour 15 minutes

Common Pattern Across Rounds

• Theoretical questions dominated each round.
• Coding questions existed but were limited (only a few coding questions across rounds).
• Emphasis areas included:
  • Java core, Spring Boot
  • SQL/JPA
  • Microservices design and system design/design patterns
  • Some coverage of testing, Kafka, and agile/sprint scenarios

---

Round-by-Round Breakdown of Questions

Round 1 (~1 hour): Java + SQL + SOLID + Testing Fundamentals

Coding (4 coding questions using Streams / Java core)

1. Stream query: employees above average

   • Input: list of employees with salaries.
   • Task:
     • Compute average salary using Java Streams.
     • Output employees whose salary is greater than the average.
   • Emphasis: “everything using streams.”

2. Map creation: employee ID → employee name

   • Input: list of employees.
   • Task: create a Map where:
     • Key: employee ID
     • Value: employee name

3. Highest salary by department

   • Input: list of employees with department and salary.
   • Task: for each department, find the employee with the highest salary using Streams.

4. String character frequency (pure Java)

   • Input: a string (example style: a b c ... d s ...).
   • Task: count character occurrences and print in a format like:
     • a2 b1 c3 d4 e2
   • Note: mentioned as pure Java, “not with streams.”

Streams-related theoretical topics (focus on return types and collectors)

• Discussion after implementing stream questions:
  • What are return types and typical use-cases for:
    • collect(...)
    • Collectors.toMap
    • Collectors.joining
    • Collectors.counting
  • filter return type and usage
• Extended discussion on:
  • when/how to apply stream operations (during problem-solving)

Java theoretical topics

• synchronizedHashMap vs ConcurrentHashMap
• Fail-fast vs fail-safe behavior in hash-based structures/iterators
• ForkJoinPool and relation to ThreadPool
• parallelStream concept and internal behavior (multi-core / multi-threading aspects)
• HashMap internal workings:
  • hash code calculation
  • value overwriting behavior
  • hash collisions
  • insertion time complexity
  • collision handling

Design patterns (Java + microservices context)

• Primary patterns repeatedly asked:
  • Singleton
  • Prototype
  • Abstract Factory
  • Factory
• Also mentioned:
  • Observer
  • Builder
• Focus:
  • why patterns help
  • what happens if patterns aren’t followed
  • how to implement patterns

SQL / JPA / Spring Data related topics

• JPA custom queries:
  • native queries
  • procedures
  • triggers
  • “what is a real procedure” vs theoretical definitions
• SQL concepts:
  • GROUP BY, HAVING, LIKE
• OOP/JPA topic:
  • abstract classes (with re-discussion “back to Java”)

SOLID principles (explained with examples)

• Single Responsibility Principle
• Open/Closed Principle
• Liskov Substitution Principle
• Interface Segregation Principle
• Dependency Inversion Principle
  • emphasis: definitions + examples + where used

JUnit / testing theory

• Marking static methods in JUnit
• Marking private methods
• Disadvantages of PowerMock
• Understanding test/mocking terms:
  • “what is Mockito?”
  • where verify is used
  • times, never
  • “any times / any parameter” expectations
  • when...thenReturn
  • what assertions are

---

Round 2 (~1.5 hours): Coding (flatMap/count) + Spring Boot + Microservices Fundamentals

Coding (only one coding question mentioned)

• Input structure:
  • list of transactions
  • each transaction has a list of items
  • each item has:
    • item ID
    • item amount
• Task: count items where item amount < 50
• Technique: flatMap and count
• Emphasis: when to use flatMap vs map vs filter, and doing the count with streams.

SOLID with examples again

• Encapsulation discussion:
  • why use getters/setters
  • make variables private
  • pros/cons

Functional interfaces

• Predicate / Supplier / Consumer
• Creating custom functional interfaces
• Using the test() method with provided inputs (scenario-based)

SQL

• Second highest salary query
• Finding customers with zero orders
  • Use case: customer table + order table
  • Task: customers who made no orders (not “how many orders”)

Spring Boot

• Filter:
  • purpose, usage, return type, and how to write custom filters
• Interceptor:
  • create custom interceptors
  • discussion: what logic belongs in filter vs interceptor
• Spring Boot request flow:
  • how filters/interceptors interact around controller/service

Java Time API

• Java 8 date-time API changes
• Immutable vs mutable classes
• Finding date differences (number of days)

Concurrency / Async

• CompletableFuture (concept and usage)
• try-with-resources
  • alternatives (closing resources with try/finally)

Spring concepts

• Dependency injection types
• Why constructor injection is better than setter injection

Eureka + Load Balancing

• What is Eureka server
• How load balancer works with Eureka
• How to register a service
• What properties to set
• When load balancing is applied (relative to API Gateway)
• What is API Gateway
• Routing with:
  • programmatic routing (Java)
  • YAML / application.properties
  • route properties: ids, predicates, conditions

Microservices design patterns / principles

• Mentions:
  • CQRS
  • Saga pattern
    • Orchestrator vs Choreography
    • key differences
  • “design patterns vs design principles” distinction
• Newer type concepts briefly mentioned:
  • sealed classes
  • records
  • anonymous/naming term mentioned as “Annamata” (unclear)

Kafka

• How to send events:
  • WebClient vs KafkaTemplate (as discussed)
  • producer/consumer concepts
• Listener:
  • @KafkaListener
• Basic configuration ideas:
  • topic registration
  • send → transmit → receive → process

WebClient vs RestTemplate

• RestTemplate vs WebClient:
  • RestTemplate typical sync
  • WebClient supports sync and async
• Reactive types:
  • Mono vs Flux
• Blocking vs non-blocking requests
• How to do both sync and async with WebClient

Agile / Scenario-Based Questions (last ~10–15 minutes)

• Agile ceremonies:
  • sprint demo
  • planning poker in sprint planning
  • sprint retrospective
• Scenario examples:
  • Junior repeatedly making the same mistake:
    • approach to fix and prevent recurrence
  • Sprint planning estimate dispute:
    • convincing someone estimated “8” vs actual “13”
  • Handling major change during remaining sprint days:
    • ensure promised deliverables are not compromised
  • Planning delivery for a large team (~10–15 members)

---

Round 3 (~1.25 hours): Architecture-level Java Data Structures + One Java-only Coding + Security/Microservices Depth

Architecture / Theory

• Internal workings:
  • TreeMap
  • TreeSet
• Comparison focus:
  • HashMap vs TreeMap/TreeSet internal behavior

Coding (only one question mentioned, 15–20 minutes)

• Input: two dates in dd/MM/yyyy format, e.g.:
  • 23/04/2024
  • 03/04/2027
• Task: compute number of days between the two dates
• Constraints:
  • must be done in Java 7 style
  • no internal date/time libraries
  • manually parse/split day/month/year
  • handle variable month lengths (30 vs 31)
  • handle cases:
    • dates are the same
    • first date is greater than second date
• Speaker note:
  • output logic wasn’t fully correct.

Serialization / Security

• Serialization vs deserialization:
  • main problem: deserialization
  • why “serialization filtering”/related mechanisms matter
  • deserialization forgery attacks:
    • how external attackers could exploit
  • how to avoid such attacks

Microservices design patterns (deeper)

• “Secure S” pattern (name partially unclear)
• Sidecar design pattern

Observability / Logging

• Logging strategy in microservices:
  • Trace ID vs Span ID
  • Trace ID constant across services
  • Span ID per service/request unit
• Navigating request flows across microservices using trace/span ids

Deployment strategies

• Blue-green deployment
• other deployment strategies

Spring Boot request lifecycle

• Full request path:
  • DispatcherServlet → filters → interceptors → controllers → services → repository → back
• Interceptor lifecycle hooks:
  • preHandle
  • postHandle
  • afterCompletion
• Filter chain:
  • what it is and how it works
  • where to place logic

Authentication & Authorization

• Basic concepts:
  • what auth is
• JWT structure:
  • header, payload, signature
• JWT claims in payload:
  • audience (primary/secondary)
  • scope
• JWT usage in microservices OAuth context
• Spring annotations:
  • @Autowired, @Qualifier (subtitle mentions others like “resource”, “inject”, “component”; unclear exact mapping)
• Differences and downsides:
  • @Autowired vs @Inject vs @Resource
• Scenario: multiple implementations and selecting the correct bean

Java memory management

• Evolution across Java versions:
  • Java 7:
    • PermGen
    • why it was moved
    • Metaspace creation
    • pros/cons
• Garbage collection topics:
  • object location over time
  • GC types mentioned:
    • serial, parallel, mark-sweep, concurrent, G1GC
  • how to invoke GC (as discussed)

Threads & Concurrency

• Coding in multi-threaded environments
• handling concurrency
• choosing thread pool size based on needs/design

JPA / Transactions

• Transaction management:
  • isolation levels
  • propagation levels
  • how to choose appropriate levels

JUnit

• spy and how to write JUnit in a Spring Boot context

---

Speaker / Source List

• Primary speaker: The YouTube video narrator/interviewee recounting their own EPAM Palm Java Microservices interview experience (name not provided).