Lead-Level Java Interview Questions and Answers

Posted on: June 26, 2025 Posted by: rahulgite Comments: 0

1. Performance Optimization of a Java Spring Boot Application

Scenario:
Worked on a high-traffic e-commerce platform experiencing latency issues and slow API responses during peak sales.

Solution Approach:

a. Database Optimizations:

  • Query Optimization:
    • Replaced SELECT * with specific columns to minimize unnecessary data fetch.
    • Optimized JOINs and subqueries for performance.
  • Indexing:
    • Created proper indexes on frequently filtered/searchable fields.
  • Caching:
    • Used Redis to cache frequently accessed data like product details, category lists, etc., to reduce DB load.

b. Code-Level Optimizations:

  • StringBuilder: Used in loops instead of regular string concatenation to reduce memory overhead.
  • Parallel Streams: Converted sequential streams to parallelStream() where thread-safety and data independence allowed.
  • Concurrent Collections: Replaced synchronized blocks with ConcurrentHashMap, CopyOnWriteArrayList, etc.
  • Async Processing: Leveraged CompletableFuture to perform non-blocking operations.
  • Request Batching: Combined small frequent DB/API calls into single batched requests.
  • Response Compression: Enabled GZIP compression for REST APIs to reduce response payload.
server:
  compression:
    enabled: true
    mime-types: application/json, application/xml, text/html, text/plain
    min-response-size: 1KB

c. Infrastructure Scaling:

  • Traffic Analysis: Identified peak hours and scaled app instances accordingly.
  • Load Balancer: Implemented to distribute load evenly.
  • CDN Usage: Cached static content closer to users to offload backend.

d. Profiling:

  • Used VisualVM and YourKit to analyze heap usage, CPU consumption, and thread dumps.

Results:

  • API response improved from 1.5s to 300ms.
  • DB load reduced significantly.
  • System handled traffic spikes with zero downtime, leading to 15% revenue growth.

Example:
A product search API that initially fetched product + inventory + reviews in one go was split into micro calls, and non-critical data like reviews was lazy-loaded and cached.

2. Legacy Code Migration to Microservices Architecture

Scenario:
A legacy monolithic financial reporting application that had scalability issues and tight coupling.

Solution Approach:

a. Initial Assessment:

  • Analyzed monolithic architecture and code dependencies.
  • Engaged stakeholders to define critical modules for initial migration.

b. Microservices Transformation:

  • Split into multiple Spring Boot microservices (e.g., Report Generation, Scheduler, Notification).
  • Ensured “One Microservice, One DB” policy with data sharding and read replicas.
  • Used Kafka and ActiveMQ for async communication between services.
  • Introduced API Gateway for unified access and security.

c. Testing and Monitoring:

  • Tools used: JMeter, Gatling for load testing.
  • Prometheus and Grafana for service health and usage metrics.
  • Introduced Redis and local caches to reduce DB pressure.

Challenges & Solutions:

  • Tight Deadlines: Prioritized services with the most performance impact.
  • Interdependencies: Used feature toggles and mocked services for testing.
  • Stakeholder Concerns: Regular sprint demos and documentation ensured trust.

Results:

  • System handled 3x transaction volume.
  • Response time improved by 40%.
  • Modular architecture cut dev time by 30%.

Example:
The monolithic report service was split into: ReportDataFetcher, DataAggregator, PDFGenerator microservices communicating over Kafka.

3. Enforcing Java Code Best Practices in a Team

Approach to Governance:

a. Coding Standards:

  • Followed Oracle Java conventions.
  • Maintained a shared coding guideline document in the project wiki.

b. Automated Code Quality:

  • Integrated CheckStyle, PMD, and SonarQube in CI/CD.
  • Blocked merge if Sonar Quality Gate failed.

c. Code Reviews:

  • Enforced mandatory peer reviews via tools like GitHub PRs or Bitbucket.

d. Testing Discipline:

  • Every feature required a minimum 70% unit test coverage.
  • Used JUnit, Mockito, and TestContainers.

e. Knowledge Sharing:

  • Biweekly learning sessions and brown-bag tech talks.

Example Scenario:

  • Team had inconsistent code style and legacy code with high technical debt.
  • Introduced refactoring sprints to reduce debt.

Action Plan & Results:

  • Enforced tools and standards.
  • Code smells reduced by 60%.
  • Delivery time improved by 25%.
  • Achieved consistent, clean, maintainable codebase.

Example:
Introduced SonarQube dashboards for each microservice repo and tied team KPIs to code quality improvement.

4. Miscellaneous Interview Points (Brief)

  • Why Code Fails Only When Debugging?
    • Debugging alters timing or thread execution paths, especially in multi-threaded apps.
    • Race conditions or improper sync blocks can behave differently under a debugger.
  • Why Production Issues Are Reproducible Locally But Not in Debug Mode?
    • Debugger slows down execution, avoiding real-time issues like timeouts or concurrency bugs.
    • Logging and debug breakpoints may mask race conditions.

Leave a Comment