Interview Experience - 157 - Microsoft | Senior Software Engineer | L63

Summary

📌 Job Role: Senior Software Engineer (Full Stack Role)
🔢 Number of Rounds: 6
📜 Offer Status: Rejected
📍 Location: Bangalore
👤 Candidate Name: Not disclosing due to signed NDA

---

Interview Process

The interview process at Microsoft for the Senior Software Engineer (L63) position in Bangalore was a comprehensive evaluation across multiple areas — coding, frontend development, low-level and high-level system design, and behavioral assessment.

The process was as follows:

1. Codility Round (Online Assessment)

2. Frontend Round

3. Low-Level Design (LLD) Round

4. High-Level Design (HLD) Round

5. Another High-Level Design (HLD) Round

6. Hiring Manager (HM) Round

It began with an online assessment, followed by technical rounds covering different domains. The final stage was the Hiring Manager round, which combined behavioral questions with another system design challenge.

---

Preparation Guide

There was no specific preparation source mentioned for this interview process. However, from the experience shared, candidates targeting such a role should focus on:

• Strong problem-solving skills in coding platforms like LeetCode and Codility.

• Frontend-specific problem solving, especially around asynchronous and concurrent execution.

• System design skills — both Low-Level and High-Level — with emphasis on scalability, extensibility, and performance.

• Behavioral interview preparation, aligning with Microsoft’s leadership principles and past project discussion.

---

Interview Rounds

Round 1: Codility Round (OA)

Duration: 90 minutes (completed in 30 minutes)
Difficulty Level: Easy

Experience:
This was a 90-minute online assessment, but I was able to complete both problems within 30 minutes with all test cases passing.
The problems were straightforward and tested basic coding and problem-solving skills.

Questions:

1. Bank Account Transactions:
   Two people have separate bank accounts. An array of transactions is provided in the format [[A, B, 20], [B, A, 10]] where each subarray denotes a transfer (e.g., A transferred $20 to B, then B transferred $10 to A). Find the minimum initial account balance required for each person and return it as an array.

2. Highest Country Account Balance:
   Multiple international bank accounts are provided in the format [COUNTRY CODE][ACCOUNT NO] such as IN00034056 or US0022312. Given a list of accounts with their balances, return the country that has the highest total amount.

Key Learnings:
While the problems were simple, accuracy and speed are important in online assessments as they set the tone for the rest of the interview process.

---

Round 2: Frontend Round

Difficulty Level: Medium

Experience:
The focus was on implementing a concurrent web crawler in JavaScript. I approached the problem using topological sort, which produced a synchronous solution. However, the interviewer was expecting an approach that supported parallel execution to maximize performance. This mismatch in approach led to a “No Hire” decision for this round.

Question:
A web crawler is crawling a webpage with multiple links. To complete crawling, we must process the links present in the current page before moving to other dependent pages. Given a dependency graph showing which page depends on which, write a JavaScript function to crawl all pages and their children as quickly as possible, using concurrency.

Key Learnings:
Need to strengthen my understanding of parallel execution techniques in JavaScript, especially using Promise.all, worker threads, or asynchronous queues.

---

Round 3: Low-Level Design (LLD) Round

Difficulty Level: Medium

Experience:
The task was to design a Logger Service. I implemented it using a simple Queue and Map, meeting the initial requirement of processing logs in order. However, the follow-up asked for making the logger extensible so that any logging logic could be added without modifying the core code. My design lacked that level of flexibility, leading to a “Lean Hire” verdict.

Question:
Design a Logger service with the following:

• A start method for starting a process.

• An end method for ending a process.

• A log method that logs all services that started earlier than any currently running process and have ended.
  Time complexity should be O(1).

Follow-up:
Extend the logger so it can take any logging logic without changing the code.

Key Learnings:
Need to improve at designing extensible systems that support dynamic behavior without code changes.

---

Round 4: High-Level Design (HLD) Round

Difficulty Level: Difficult

Experience:
The problem was to design an online collaborative editor that supports both text and images. I proposed a solution using WebSocket for real-time synchronization. However, the interviewer was not fully satisfied with the approach and details provided.

Question:
Design an online editor that supports collaborative editing for text and images.

Key Learnings:
Need to explore real-time collaborative architectures in more detail, including conflict resolution strategies (like Operational Transformation or CRDTs).

---

Round 5: High-Level Design (HLD) Round

Difficulty Level: Difficult

Experience:
The problem was to design an autocorrect system for an editor/keyboard. I proposed a high-level design using Elasticsearch for efficient lookups and autocorrect suggestions. The interviewer appreciated the high-level design but wanted an algorithm-level implementation of the autocorrect logic. I explained a backtracking approach, but it wasn’t strong enough to get a “Strong Hire” verdict.

Question:
Design an autocorrect system for an editor or keyboard, and implement the autocorrect logic.

Key Learnings:
Need to balance high-level design with low-level algorithmic detail, especially for product features like autocorrect.

---

Round 6: Hiring Manager (HM) Round

Difficulty Level: Medium

Experience:
This round was a mix of behavioral and technical questions. It began with a deep dive into my past projects and the challenges faced. The technical portion involved designing an Expense Management System with a submission and approval workflow. While the Hiring Manager appeared satisfied during the discussion, HR later communicated that the feedback was negative.

Question:

• Behavioral: Discuss previous projects, challenges faced, leadership experiences.

• Technical: Design an Expense Management System with submission and approval features.

Key Learnings:
Even if the conversation feels positive, the final decision may depend on evaluation metrics and factors that are not directly visible to the candidate.

---

Final Thoughts

While the result was a rejection, the process provided deep insights into the expectations for a Senior Software Engineer at Microsoft. The key takeaways are:

• Ensure you can bridge the gap between synchronous and asynchronous/concurrent programming.

• In system design, address both scalability and extensibility, with clear reasoning for architectural choices.

• Be prepared to drill down from high-level designs to low-level algorithms when prompted.

• Behavioral interviews matter as much as technical skills; align answers with company values.