Rupeek SDE-3 Interview Experience (3 Rounds ~ Coding, LLD & HLD)

I recently interviewed for the SDE-3 role at Rupeek and wanted to share my complete experience because while preparing, I could not find many detailed experiences for senior-level interviews at the company. Hopefully this helps developers preparing for backend engineering, system design and senior software engineer interviews.

The overall process was focused less on competitive programming tricks and more on how you think as an experienced engineer. The interviewers were interested in problem solving, object-oriented design, scalability, concurrency handling and decision-making ability. Since this was for an experienced role, they expected clear communication and strong reasoning behind every design choice.

I prepared seriously for around 3 months before the interviews. My preparation was mainly focused on Data Structures & Algorithms, Low Level Design, High Level Design, Java fundamentals, concurrency and object-oriented design principles. One thing I realized after the interviews is that for senior roles, simply solving coding questions is not enough. You need to explain trade-offs, justify architecture decisions and communicate like someone who has worked on scalable systems.

The process had 3 rounds in total.

Round 1 – DSA / Coding Round

The first round was a video interview of around 60 minutes. The interviewer started with a short discussion about my previous projects and the kind of systems I had worked on. After that, we moved directly into coding.

The main coding problem asked was: Size of Largest BST in Binary Tree

The question was based on binary trees and BST validation. At first glance it looked like a normal tree problem, but the interviewer was more interested in the approach and optimization rather than only the final solution.

The interviewer specifically asked me to explain:

• Why brute force would be inefficient
• How to validate BST properties efficiently
• How information should flow bottom-up in recursion
• Time and space complexity analysis
• Edge case handling

I started with a naive approach and then optimized it using post-order traversal where each recursive call returned information about:

• minimum value
• maximum value
• subtree size
• whether the subtree is BST or not

The interviewer continuously asked follow-up questions while coding. It felt more like a discussion than an exam. They also checked code structure, variable naming and how cleanly I explained recursion.

One important observation from this round was that communication mattered a lot. Even when I was thinking, the interviewer expected me to explain my thought process clearly instead of staying silent.

If you are preparing for this round, I would strongly recommend focusing on:

• Trees and Binary Search Trees
• Recursive DFS-based problems
• Bottom-up tree DP concepts
• Complexity analysis
• Writing production-quality code instead of only and LeetCode style code

Round 2 – Low Level Design (LLD)

The second round was again around 60 minutes and focused completely on Low Level Design. The interviewer asked me to design a Parking Lot System. Initially the problem sounded straightforward, but the discussion quickly became deeper. They were not looking for only classes and objects. They wanted to evaluate how well I understood real-world system behavior.

The discussion included:

• Different vehicle types
• Parking spot allocation strategy
• Entry and exit management
• Ticket generation
• Pricing calculation
• Multiple floors
• Extensibility of the system
• Thread safety and concurrency handling

The concurrency part became very important in this round. The interviewer asked what would happen if multiple vehicles tried to book the same parking spot simultaneously. We discussed synchronization, locking strategies, race conditions and maintaining consistency in a multi-threaded environment.

The interviewer also checked whether the design followed SOLID principles and proper object-oriented design practices. They challenged many assumptions in my design and asked how I would extend the system in the future without breaking existing code.

This round taught me that for senior backend interviews:

• Class diagrams alone are not enough
• Concurrency knowledge is extremely important
• Design patterns should be applied naturally
• Extensibility and maintainability matter a lot

If you are preparing for senior LLD interviews, practice problems like:

• Parking Lot
• Cab Booking System
• Food Delivery System
• Library Management
• Elevator System

Practice this sheet Low Level System Design Sheet - Fast-Track to Cracking Tech Interviews

Also prepare topics like:

• Design patterns
• SOLID principles
• Thread safety
• Java concurrency
• Interfaces vs abstract classes
• Composition over inheritance

Round 3 – High Level Design (HLD)

The final round was the toughest one for me. It was another 60-minute discussion focused entirely on High Level Design.

The problem statement was: Design Ludo

At first, I thought this would mainly test gameplay logic, but the interviewer gradually converted it into a distributed systems discussion. We discussed:

• Multiplayer architecture
• Real-time communication
• State synchronization
• Matchmaking
• Handling reconnects
• Scalability for thousands of concurrent users
• Session management
• Fault tolerance
• Database selection
• WebSockets and event-driven communication

The interviewer wanted me to think like a system architect instead of just a backend developer. Every design choice was questioned:

• Why choose this database?
• Why not cache this data?
• What happens if a node crashes?
• How would you reduce latency?
• How would you synchronize turns between players?

One thing I appreciated was that the interviewer gave hints whenever I got stuck. The discussion became highly collaborative and practical.

However, I realized later that I could have structured my architecture discussion better. In senior-level HLD interviews, structure matters a lot:

• Clarify requirements
• Estimate scale
• Define APIs
• Design components
• Discuss database
• Discuss scaling
• Discuss bottlenecks
• Discuss optimizations

Without a structured flow, it becomes easy to miss important areas.

Final Result

Unfortunately, I got rejected after the final round. Although rejection feels disappointing, this interview helped me understand what companies expect from experienced engineers. For SDE-3 roles, interviewers evaluate much more than coding ability. They expect:

• Strong problem-solving skills
• Clean communication
• Real-world engineering thinking
• System design depth
• Concurrency understanding
• Confidence in decision-making
• My Preparation Tips for Rupeek SDE-3 Interviews

If you are targeting senior backend or SDE-3 level roles at companies like Rupeek, here are a few things I would strongly recommend:

• First, do not prepare only DSA. Coding rounds are important, but system design carries huge weight in experienced interviews.

• Second, spend serious time on Low Level Design. Many candidates underestimate LLD, but companies now ask deep questions about maintainability, scalability, concurrency and extensibility.

• Third, practice explaining your thoughts clearly. Communication is one of the biggest differentiators at senior levels.

• Finally, be confident in your decisions. Interviewers may intentionally challenge your design choices to see whether you can defend them logically.

Overall, the interview experience was challenging but genuinely good from a learning perspective. The interviewers were knowledgeable, interactive and focused on practical engineering rather than memorized answers. Even though I was rejected, the process gave me a clear understanding of what I still needed to improve for senior software engineering roles.