Truemeds SDE-2 Backend Interview Experience

Published : 25 May 2026

19 Views

#interview-experience

Recently, I interviewed for an SDE-2 Backend Developer role at Truemeds and honestly, this was one of the most practical backend engineering interviews. I've attended in recent times. The process was not focused only on solving LeetCode-style coding questions. Instead, the interviewers tried to evaluate whether I genuinely understood backend development fundamentals deeply enough to work on production-scale systems.

The interview process mainly revolved around:

Java internals
Spring Boot
SQL and NoSQL databases
Microservices architecture
Problem-solving in Java
API and distributed system concepts

What made this interview different from many product-company interviews was the balance between coding and conceptual clarity. Even though the DSA questions were not extremely hard, the follow-up discussions were quite deep. The interviewers constantly tried to understand whether I truly knew why certain technologies or patterns are used in backend systems instead of just memorizing definitions.

The complete process happened remotely and took around 1–2 weeks. Unfortunately, I was rejected after the second round, but the experience itself was extremely valuable because it gave me a clear understanding of what companies now expect from backend-focused SDE-2 engineers.

Interview Process Overview

The process consisted of 2 technical rounds.

The first round was more comprehensive and covered multiple backend topics including Java internals, Spring Boot, databases and coding problems.
The second round focused more on advanced backend concepts, practical engineering discussions and one additional coding question.

One thing became very clear after the interview: Backend interviews are increasingly becoming concept-heavy

A lot of developers prepare only DSA, but companies hiring backend engineers now expect good understanding of:

Spring Boot internals
API architecture
concurrency
distributed systems
SQL optimization
microservice communication
scalability concepts

Especially for SDE-2 roles.

Round 1 – Java, Spring Boot, SQL & Coding

The first round was around 90 minutes and conducted through BarRaiser. The interviewer was quite experienced and structured the discussion very well. Instead of randomly asking questions, he divided the round into separate areas and explored each topic carefully.

The round started with my resume discussion and backend project experience. After that, we gradually moved into databases, Java internals, Spring Boot concepts and finally coding problems.

What I personally liked was that the interviewer was not trying to intimidate me. The discussion felt technical but collaborative, almost like two backend engineers discussing system decisions.

Database Discussion

The database section was much deeper than I expected. The interviewer first asked about SQL vs NoSQL databases. Instead of asking textbook differences, he wanted to understand whether I knew when to use each database type in real systems.

I explained that relational databases like MySQL or PostgreSQL are usually preferred when:

strong consistency is required
transactions are important
relationships between entities are complex

On the other hand, NoSQL databases like MongoDB are useful when:

schema flexibility is important
data grows rapidly
horizontal scaling is required

The discussion then shifted toward normalization. Instead of simply defining normalization, I explained how normalization helps reduce redundant data and improves consistency inside transactional systems. I also mentioned that excessive normalization sometimes increases join complexity, so in real-world systems there is often a balance between normalization and performance optimization.

The interviewer then asked one SQL-related question that many backend engineers should honestly expect in interviews.

SQL Question – Find Users Inactive for More Than 90 Days

The problem statement was simple: You have a users table with a last_login_date column. Write a query to find users who have not logged in for more than 90 days.

I explained my thought process first before writing the query because interviewers often care more about clarity than speed.


SELECT *
FROM users
WHERE last_login_date < CURRENT_DATE - INTERVAL '90 days';

After this, the interviewer also asked about GROUP BY and HAVING.

Instead of giving short textbook definitions, I explained with examples. I mentioned that:

GROUP BY is used to group records
HAVING is used to filter grouped results

For example:


SELECT department, COUNT(*)
FROM employees
GROUP BY department
HAVING COUNT(*) > 5;

The interviewer seemed satisfied because the explanation was practical rather than theoretical.

Another interesting question was: How does MongoDB handle massive datasets?

Here I discussed:

sharding
replication
indexing
horizontal scaling

I explained how MongoDB distributes data across multiple shards to improve scalability and how replication improves fault tolerance and availability.

This part of the interview felt more like a backend architecture discussion rather than a rapid-fire interview.

Java Internals and Spring Boot Discussion

This was probably the longest section of the interview and honestly the most important one. The interviewer went very deep into Java and Spring Boot fundamentals.

API Gateway in Microservices

One question was: Why do we need an API Gateway in microservices?

Instead of giving a one-line answer, I explained it like a real backend system. I described how an API Gateway acts as a centralized entry point for all client requests and helps manage:

authentication
routing
load balancing
rate limiting
request aggregation
monitoring and logging

I also mentioned that without an API Gateway, clients would need to communicate directly with multiple microservices, making the system harder to manage and secure.

The interviewer then asked follow-up questions around scalability and fault tolerance.

Circuit Breaker Pattern

Another very important microservices question was: What is a circuit breaker and why is it important?

I explained this with a real-world analogy. I said that if one downstream service continuously fails, repeatedly calling that service can overload the entire system. A circuit breaker temporarily stops requests to the failing service and optionally provides fallback responses. I also mentioned libraries like:

Resilience4j
Hystrix (older)

This discussion became surprisingly detailed because the interviewer also asked how retries differ from circuit breakers and when retries can actually worsen failures.

Container Orchestration

The interviewer then moved toward DevOps-related backend topics. He asked: What is container orchestration?

I explained that orchestration tools help automate: deployment, scaling, monitoring, networking, container lifecycle management

I discussed Kubernetes briefly and how it helps manage distributed containerized applications efficiently. This was one of those moments where I realized backend interviews now increasingly expect engineers to understand infrastructure concepts as well.

Java Generics

The interviewer also asked about generics in Java.

Instead of only defining generics, I explained why they matter in real applications. I mentioned that generics:

provide compile-time type safety
reduce runtime errors
improve code reusability

For example:

List<String> users = new ArrayList<>();

This prevents accidental insertion of invalid object types.

Shallow Copy vs Deep Copy

This question looked simple initially, but the interviewer explored edge cases.

I explained that Shallow Copy : copies object references while Deep Copy : creates completely independent objects recursively.

I also explained why shallow copy can cause unintended side effects when mutable objects are shared.

Spring Boot Annotation Questions

The interviewer asked many practical Spring Boot questions including:

@SpringBootApplication
@Repository
@Service
@Autowired
@AutoConfiguration

What I noticed was that he did not want memorized definitions. He wanted to understand:

when these annotations are used
what happens internally
why Spring Boot uses them

For example, when discussing @Repository, I explained that apart from marking persistence-layer components, it also enables exception translation in Spring. That level of explanation matters a lot in backend interviews.

Coding Problem 1 – Move Zeroes

After the conceptual discussions, we moved toward coding. The first coding problem was: Move all zeroes to the end while maintaining order of non-zero elements

Example:


Input: [0,1,0,3,12]
Output: [1,3,12,0,0]

At first glance this looks easy, but interviewers still evaluate: clean coding, edge case handling, optimization.

I used the two-pointer approach. The idea was simple: One pointer keeps track of the next position where a non-zero element should be placed.


public class MoveZeroes {

    public void moveZeroes(int[] nums) {
        int index = 0;
        for (int num : nums) {
            if (num != 0) {
                nums[index++] = num;
            }
        }
        while (index < nums.length) {
            nums[index++] = 0;
        }
    }
}

The interviewer asked about: in-place optimization, time complexity, stability of order.

So always explain those during interviews.

Coding Problem 2 – Implement Stack Using Array

The second problem was simpler conceptually but focused more on implementation clarity. I was asked to implement stack operations using arrays. Operations included: push, pop, peek, isEmpty.

Instead of rushing into code, I first discussed: overflow conditions, underflow conditions, stack pointer management.

That discussion actually mattered more than the final syntax.


class Stack {

    int[] arr;
    int top;
    int size;

    Stack(int size) {
        this.size = size;
        arr = new int[size];
        top = -1;
    }
    void push(int value) {
        if (top == size - 1) {
            System.out.println("Stack Overflow");
            return;
        }
        arr[++top] = value;
    }
    int pop() {
        if (top == -1) {
            System.out.println("Stack Underflow");
            return -1;
        }
        return arr[top--];
    }
    int peek() {
        if (top == -1) return -1;
        return arr[top];
    }
}

Round 2 – Advanced Backend Concepts + Coding

The second round was shorter but conceptually more challenging. This round focused heavily on backend engineering maturity and practical Spring Boot understanding.

The interviewer seemed more interested in:

architectural reasoning
debugging capability
production-level thinking

rather than just DSA.

Coding Problem – Container With Most Water

The coding question was: Container With Most Water

This is a classic two-pointer problem. Initially, brute force seems obvious because you can try every pair of lines, but that leads to O(N²) complexity.

I explained how the two-pointer approach optimizes the problem significantly.

The key insight is: The area depends on smaller height and distance between lines So moving the larger pointer is useless because area is constrained by the smaller height.


public class ContainerWithMostWater {

    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int maxArea = 0;
        while (left < right) {
            int area = Math.min(height[left], height[right])
                    * (right - left);
            maxArea = Math.max(maxArea, area);
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }
        return maxArea;
    }
}

The interviewer mainly focused on whether I could justify why the two-pointer optimization works.

Advanced Spring Boot Questions

This section became more discussion-oriented. Topics included:

constructor injection vs field injection
circular dependencies
pagination in Spring Boot
@Transactional
@Profile
Elasticsearch integration
deadlock handling in threads

For deadlocks, I explained: lock ordering, avoiding nested synchronization, timeout strategies, using concurrent utilities

The interviewer also asked about Java Stream API's groupingBy() collector and practical use cases.

One Important Mistake I Made

Although I solved the coding questions correctly, I struggled in some deeper conceptual follow-up questions. At SDE-2 level, interviewers often keep digging until they find the depth of your understanding.

For example:

not just what is pagination but how pagination behaves under massive datasets
offset vs cursor pagination
performance trade-offs

That depth matters a lot. Another small challenge was understanding the interviewer's accent in a few moments, which slightly affected the flow of communication.

Final Result – Rejected

Unfortunately, I was rejected after the second round. But honestly, this interview taught me something very important: Backend interviews are no longer just about coding problems Companies increasingly expect engineers to understand:

production systems
backend architecture
distributed systems
Spring Boot internals
database scaling
resilience patterns

especially for SDE-2 backend roles.

What I Learned from This Interview

If you're preparing for backend interviews at companies like Truemeds, focus deeply on:

Java internals
concurrency
Spring Boot
SQL optimization
microservices patterns
REST APIs
Docker/Kubernetes basics
distributed systems concepts

And yes, DSA still matters, but mostly: arrays, two pointers, stacks, medium-level problem solving. The real differentiator becomes conceptual clarity.

Final Advice for Backend Engineers

One mistake many developers make during preparation is studying topics superficially. Instead of memorizing: What is circuit breaker? understand:

why it exists
when it fails
how it behaves under retries
real production trade-offs

That depth is exactly what backend interviews test today. And honestly, that is what separates an average backend developer from a strong SDE-2 engineer.