YOE: ~10.3
Role: Lead Software Engineer/LMTS - Backend - Distributed Systems
Recruiter Approached.

Screening round : Hackerrank

2 Questions to be completed in 75 min.
Both were leetcode medium level.
This is a proctored test. Your microphone and video will be ON and recorded throughout.

Q1 : I solved it using binary heaps (Priority queue if you are using java). Once you figure out that you need to use a binary heap for this, its straight forward to solve. If you practice some good number of binary heap concepts, you will be able to solve this.
Watch out a little when handling inputs with large numbers.

Q2 : This was a little tricky question. You can solve this using basic DP or by using a combination of sorting and math. I chose to solve this using sorting and math. This question took some time to figure out the approach.

All the test cases were green for me for both the questions when I submitted the test. They will run another set of test suites after the submission.

I got the call back from HR the next day only communicating that we will be going ahead with next rounds of interviews.

Round 1 : DSA

It was virtual, over google meet.

• Basic introduction about the work we do and asked about a challenging situation I recently handled in the project and dug into the technicalities of it. The interviewer was smart enough to gauge the candidate and did not invest more than 10 min for this discussion.
• He asked to implement a max stack. A variation of this question in leet code is this one - https://leetcode.com/problems/min-stack/description/
• I took some time to think through and explained my approach in excalidraw by drawing. This explaining by drawing really made the difference. I was able to easily onboard the interviewer on to my thinking process. There was absolutely 0 communication gap between us.
• Initially, I did this with higher time compplexity and the interviewer probed to reduce the complexity further and further. He was not satisfied until I reduced it to O(1). He was clear that we are not going to write code till we finalise and come up with most optimal solution.
• Once I figured out O(1) approach, he asked me to write code for this. I wrote in java and the expectation was to write a fully functional implementation with various test cases.
• There were 15 min left and he asked me to implement frequency stack. You can find this here - https://leetcode.com/problems/maximum-frequency-stack/description/
• In the left over 15 min, I was able to come up with the approach and again explained it with excalidraw by drawing and did not have time to write code for this. I sensed that the interviewer was quite convinced with the way I did.
• He concluded the interviewe by wishing me good luck for my next round.

Note: Excalidraw is my way of explaining. You might be good in a different way. Experiment and fix on on thing. Don't take me for granted :)

Round 2 : LLD

It was virtual, over google meet.

• Basic introduction about the work we do and the roles and responsibilities. Did not go beyond 5-6 min for this discussion.
• Then there was discussions on some databases, sharding, partitioning -- when to choose what. I explained why I would be scared of sharding the data and why that solution would be a worst-case scenario for me. (As sharding brings in lot of complexities and has to be chosen and dealt very carefully)
• Some discussions on scalability and he checked if I have practical knowledge of the things I am talking.
• All the above discussion took around 15-17 min. We were left with 40 min.
• Here comes the LLD question: Implement a connection pool. Thats it !
• My mind was blank for decent number of seconds. I was not able to think of any patterns and all. I took sometime, slowly I regained myself and started asking back the questions. Below is the summary after I clarified the requirements:

1. Its a connection pool of 1000 - 2000 connections 
2. The developers who will use your interface can request for a connection. 
3. If there is a free connection in the pool, you give the connection to the requester.
4. Once the connection is used by the developer, they can return back the connection to the pool Or close the connection.
5. If the connection is closed, create a new connection and keep it in the pool. The count of the connections should be maintained throughout.
6. A Connection will have 3 states - FREE, BLOCKED, CLOSED. 
7. If the connections in the pool are exhausted, and requests for connections are coming from developers, keep an in-house mechanism to a default timeout and reject the request if there is no connection being freed within that default timeout. If you get a connection within the time, return the connection. 

Implemented this having many discussions with the interviewer. Throughout the interview, I was thinking out loud and explaining my thought process to the interviewer before I wrote every single line of code.

I had the buy-in from the interviewer for every logical step I reached in the implementation. This helped me in being clear with the approach and avoided revisiting what ii decided and wrote in the code.

The interviewer was particularly interested in how I handled the concurrency when there are multiple requests coming and we have only limited connections. I used a blockingQueue to maintain the pool and made the methods synchronous where even applicable.

With respect to the default timeout. I implemented this in O(n) for checking the connections in queue on thier status. I did this as we have only 1000 - 2000 connections. I called out that I am doing this in the interest of time and if the connections were in the range of 10^6, I will probably use 2 different blocking queues. One queue for closed and another queue for open connections. I said I will revisit this logic if I get time and added a TODO there in the code and went ahead with the rest of the implementation.

I made sure that I had checked all the requirements and I was out of time already.

Interviewer appreciated the callout I made for choosing O(n) and proposing a better solution before I moved on. He was ok with not implementing this in the code, as we already crossed the time.

The interviewer gave 5 min at the end for any questions I had to ask.

I got the call for Round 3 after 2 weeks from my Round 2

Round 3 : HLD

This was an in person round, whiteboard interview. Took place in the office.

• Interviewer asked me to design a marketing campaign.
• Like in any general HLD interview, I clarified the requirements and started drawing while I explained my thought process.
• The interviewer was not interested in the complete solution. He was very interested in the deep dives.
• Everytime I drew / proposed something, he went very deep into the proposal asking for justification and reasoning. I guess you have to be very thorough in the solutions you propose.
• It was a good discussion and the interviewer course-corrected me 2 times.
• Most of the deep dives went on distributed transactions, scalability, distributed architectures, failure handling, self-healing system, a little on saga pattern

Round 4 : HM

This was an in person round, white board interview. Took place in the office.

• HM asked about my current project.
• Grilled a lot deeper into the current architecture I work on.
• This went for ~45 min
• Then behavioral questions, questions on my roles and resposilities.
• He checked on leadership and mentoring traits etc.
• He checked about my notice period while we walked out of the room.

I got the call from HR the next day hinting that the feedback was positive and confirmation call the following day.

Compensation details:
https://leetcode.com/discuss/post/7202836/salesforce-lmts-compensation-should-i-ne-q7kl/

I will add the preparation strategy later in a separate post.