Epam - Round 3 | Coding Rd | Java, Microservices, Spring Boot, Design Pattern, Kafka, AWS, SQL/JPA

Technological concepts & architecture (microservices / Spring)

The project is being built from scratch using domain-driven design (DDD) for microservices (“domain-managed services”).

Microservices split by domain

Microservices are separated by domain, for example:

• User domain
• Access rights domain
• Account domain
• Business domain

API Gateway (Spring Cloud Gateway) as frontend controller

A central API Gateway implemented on Spring Cloud Gateway acts like a frontend controller:

• Routes requests coming from both the UI component and backend to the relevant domain microservices
• Performs load balancing and throttling

Security model at gateway and service access level

The gateway and services use a layered security model:

• A short-lived “non-token” (JWT-based, 10-second validity) identifies the consumer at the API level (gateway level)
• Uses asymmetric crypto / key pairs:
  • Consumer holds/creates a private key
  • Gateway (“ng-router” / EPAM controller) holds the public key
• The gateway verifies the JWT signature before proceeding

Authentication / authorization via two tokens

For accessing domain services, requests must include two tokens:

1. Non-token: gateway-level identification (JWT, 10s validity)
2. O-token: application-level authentication token (JWT, 10 minutes validity)

Token encryption/signing details

• Gateway token uses JWS (signed token)
• O-token uses a JWE-style approach:
  • payload is encrypted
  • payload is not directly readable

DDD benefits called out

DDD is used to separate functionality and service composition boundaries:

• A UI can call a domain service (e.g., “user service”) without coordinating multiple internal microservices manually
• The UI/backend can decide which service boundary to consume

Monitoring / health / tracing

• Grafana is used for monitoring dashboards
• Spring Boot Actuator endpoints are used for service health/monitoring
• Tracing tools are mentioned alongside Grafana
• The team configures dashboards based on exposed endpoints (e.g., info/status endpoints)

CQRS pattern

The transcript mentions CQRS (Command Query Responsibility Segregation):

• Separates read (query) and update (command) concerns
• Ensures read/write entities are not tightly interconnected
• Microservices can:
  • retrieve entities for processing
  • use separate update objects for writing

Zero-downtime deployment strategy (rollback-based)

A deployment strategy is described as supporting zero downtime with rollback:

• Corporate tooling/cube supports rollback
• If rollback fails, it rolls back to the prior known-good state

Agile methodology & delivery practices

• Development follows Scrum
• Ceremonies mentioned:
  • Sprint planning
  • Daily stand-up
  • Sprint review
  • Review after deployment completion

Git branching strategy

• Branches are created based on Jira/boards and integrated with Bitbucket
• Supports:
  • Feature branches
  • Fix branches
  • Bug fix branches
  • “Custom user” / “serial” branches (as named in the transcript)
• Feature branch naming is partially auto-derived from board descriptions

Testing / JUnit / tooling

• Emphasis on unit testing for APIs
• JUnit 4 mentioned (compatibility with their Spring 3 setup)
• Exception handler testing approach:
  • Use try/catch
  • Validate results using assertions, including assertions for specific exception types

GitHub Copilot

• GitHub Copilot is used for some code suggestions
• Engineers still write at least parts of the tests and logic

REST concept discussed: “idempotency” (element potency)

The transcript discusses REST element potency, aligned with HTTP idempotency:

• Example: repeated POST creates new resources each time (not idempotent)
• Contrasts general behavior with GET/PUT/PATCH-like patterns, where repeated calls do not repeatedly create new resources

Java / JPA / Spring Boot technical Q&A

Java & composite primary keys

• Java 17 is used
• Composite primary keys:
  • If one column isn’t sufficient to uniquely identify a row, use a composite key
  • In Spring/JPA, implement with @Embeddable / @EmbeddedId (“embeddible id”)

Multiple databases in a Spring Boot app

Approach described:

• Create multiple DataSource beans
• Configure custom properties per database
• Use conditional loading/selection (e.g., conditional bean creation)
• Mark one bean as primary if needed
• Create repositories wired to the correct datasource configuration

SQL interview exercise described

Example schema includes tables like:

• customers
• orders
• shipping

Task: write SQL to find customers who ordered multiple different products Example mentioned: customer ID 4 ordered both keyboard and mouse.

It also mentions combining/merging tables (e.g., via UNION or join-like approaches).

Coding exercises (algorithmic)

Pattern counting in strings

• Count how many times a substring/pattern repeats in an input string (e.g., “xx”, “dc”, etc.)
• Output counts per pattern
• If a pattern appears only once, output “1”

Aggregating employee earnings across departments

• Employees can appear in multiple departments with different salaries
• Need total salary per employee
• Output employees sorted descending by total salary

Product/company context (misc)

The interviewee indicates there are many Java microservice opportunities, described as over 50 Java microservices requirements from different customers, and project selection happens after connecting to the system.

---

Main speakers / sources (from transcript)

• Interviewer(s): EPAM interviewers, appear to speak in prompts/questions
• Interviewee (candidate): answers technical questions
• “Kushbu”: mentioned repeatedly as a participant
• “Akash”: thanked at the end; likely the interviewer or host