Linkedin Phone Screen | SSE | Bengaluru
SDE IILinkedIn Phone Screen Senior Software Engineer - Systems Infrastructure
Senior Software Engineer - Systems InfrastructureLinkedin - SSE System and Infra Role- First Screening Round experience - waiting for the next update
SSE System and Infra RoleLinkedIn SSE Interview Experience
SDE IILinkedIn | SSE | Systems Infra | Bengaluru | Offer
SSE | Systems Infra3 more experiences below
Summary
I recently completed a phone screen interview with Linkedin for an SSE role in Bengaluru, which covered various technical topics and a specific LeetCode problem.
Full Experience
I had a phone screen interview for an SSE position at Linkedin in Bengaluru. The discussion began with my current projects, where I was asked to elaborate on the most complex project I've worked on and suggest potential improvements to the system. Following this, the interviewer delved into core Java and Object-Oriented Programming (OOPS) concepts. We then moved on to Operating Systems, Multithreading, and Concurrency topics. The final part of the interview involved solving a specific LeetCode problem.
Interview Questions (1)
Given a nested list of integers, nestedList, where each element is either an integer or a list (which can itself contain integers or other lists), calculate the sum of all integers in the list weighted by their depth. The weight of an integer is calculated from the bottom up. That is, the deepest integers have the largest weight. If the maximum depth of any integer in the nested list is maxDepth, and an integer is at depth d (where the root list is depth 1), its weight will be maxDepth - d + 1. For example, for [1,[4,[6]]], the max depth is 3. The integer 1 is at depth 1 (weight 3), 4 at depth 2 (weight 2), and 6 at depth 3 (weight 1). The sum would be (13) + (42) + (6*1) = 17.
Summary
I recently completed a phone screen for a Senior Software Engineer - Systems Infrastructure role at LinkedIn, where the primary focus was on a challenging graph traversal problem related to determining connection distances between users in a social network.
Full Experience
My phone screen at LinkedIn started with a brief introduction, after which the interviewer presented a fascinating problem. The core task was to calculate the connection distance, essentially the shortest path, between any two users in a hypothetical LinkedIn network. They provided clear examples, like Bob-Alice-Frank having a distance of 2, which immediately cued me into thinking about graph algorithms. I spent some time clarifying the constraints and edge cases, then proposed a Breadth-First Search (BFS) approach. I walked through the algorithm step-by-step, discussing how I would represent the network (adjacency list), manage visited nodes to prevent cycles, and efficiently find the shortest path. We also talked about the time and space complexity of my solution. I felt confident in my explanation and approach.
Interview Questions (1)
LinkedIn is designed to connect people together, so that in people search and other related areas and LinkedIn will show a connection distance between two users.
E.g., Bob connects with Alice, and Alice connects with Frank, assuming there is no other connections, then Bob and Frank's connection distance is 2.
Examples:
Bob: ["Alice", "John"]
Alice: ["Bob", "Frank", "Lucy"]
Frank: ["Alice"]
John: ["Bob", "Jenny"]
Jenny: ["John", "Lucy"]
Lucy: ["Jenny", "Alice"]
The connection distance between Bob and Frank is 2
the connection distance between Lucy and Bob is 2, although there is a connection chain for Bob → John → Jenny → Lucy, but Bob → Alice → Lucy is shorter
Preparation Tips
My preparation primarily involved consistent practice on LeetCode, focusing heavily on graph algorithms, especially BFS and DFS, as these are common in system-level problems. I also reviewed common data structures and their appropriate use cases. Additionally, I spent time on behavioral questions to ensure I could articulate my experiences effectively.
Summary
I recently completed my first technical screening round for an SSE System and Infra Role at Linkedin. The round included a coding question similar to LeetCode's Number of Islands and a discussion on my past projects and OS fundamentals. I am currently awaiting an update on the next steps.
Full Experience
I recently completed my first technical screening round for an SSE System and Infra Role at Linkedin. The interview started with a coding question that was quite similar to LeetCode's Number of Islands (Problem 200). I spent a good portion of the time working through that problem. Following the coding segment, the interviewer shifted to a discussion about my past projects, where I talked about some of my relevant experiences. We also delved into some operating system basics. It was a comprehensive round, and I'm currently waiting to hear back about the next steps.
Interview Questions (1)
A coding problem similar to LeetCode problem 200, Number of Islands. The problem typically involves given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), and you need to count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
Summary
I interviewed for the SSE role at LinkedIn, navigating a comprehensive process including phone screens and multiple onsite rounds covering coding, system design, and technical communication. Overall, it was a valuable learning experience, and I enjoyed the discussions.
Full Experience
I recently went through an interview process for the SSE role at LinkedIn, which was a very insightful and comprehensive experience.
The first step was a Phone Screen, where I was given two coding problems. The first problem asked me to rotate a linked list by n nodes, and the second was to find the maximum sum subarray in a given array. I successfully solved both problems, explaining edge cases and detailing the time and space complexities to the interviewer's satisfaction. Shortly after, the recruiter called me to schedule the onsite loop.
My Onsite Round 1 (Coding) presented two more challenges. The first was to check if a graph is bipartite, given as a list of key–value pairs. I provided working code for this, but the interviewer suggested optimizing space usage by avoiding multiple arrays, and we ran out of time discussing this. The second problem involved processing logs with function names, start times, and end times to calculate the total and exclusive time taken by each function. I successfully solved this as well, delivering working code.
Onsite Round 2 (Coding) continued with two classic problems. The first was the Celebrity Problem, where I needed to find a person known by everyone but who knows no one in a given matrix. The second involved finding the maximum length of consecutive 1’s in a list of 0’s and 1’s, where some 0’s could be flipped. I tackled both problems efficiently, providing working code within the time limit and clearly explaining my logic, test cases, and edge cases along with their complexities.
The Onsite Round 3 (System Design) focused on designing an Exception Metric Collection and Alarming System. This system needed to handle millions of exceptions per second, support keyword-based searches, provide Top K frequent and least frequent exception queries, and include an alerting mechanism for specific thresholds. I felt this round went well; I was able to define functional and non-functional requirements, discuss scale, entities, and APIs, and propose a design that met the stated requirements. I did face a minor challenge with a follow-up question about Elasticsearch internals, as I hadn't worked with it hands-on, and couldn't answer it fully.
Next, the Onsite Round 4 (Technical Communication) was less about coding and more about my past large-scale projects. We discussed design decisions, trade-offs, technology choices, alternatives, and considerations for scalability and reliability. I thoroughly explained my project architecture and the reasoning behind my design choices.
Finally, the Onsite Round 5 (Host Manager Round) began with an overview of my past projects. We then moved on to why I was interested in LinkedIn and this particular role. The round also included a real-world design problem: building a system to collect feature button click counts and display aggregated metrics over time for Product Managers. I articulated my motivations for joining LinkedIn and how my experience aligned with the role, and for the design problem, I approached it methodically, covering data collection, aggregation, and scalability.
Overall, it was a great experience. Each round effectively tested different engineering dimensions, including algorithms, system design, and communication skills. I learned a lot throughout the process and thoroughly enjoyed all the conversations. 🚀
Interview Questions (8)
Rotate a linked list by n nodes.
Find the maximum sum subarray in a given array.
Given a list of key–value pairs representing nodes, determine if we can divide them into two groups such that no key–value pair belongs to the same group.
Given logs with function name, start time, and end time — find:
- Total time taken by each function
- Exclusive time excluding sub-function execution.
Given a matrix of people, find if there’s a person who is known by everyone but doesn’t know anyone.
Given a list of 0’s and 1’s where some 0’s can be flipped to 1’s, find the maximum length of consecutive 1’s that can be formed.
Design an Exception Metric Collection and Alarming System.
- Handle millions of exceptions per second.
- Support keyword-based search for exceptions.
- Provide Top K most frequent and Top K least frequent exception queries.
- Include an alerting mechanism when specific exceptions cross a threshold.
Build a system to collect feature button click counts and show aggregated metrics over time for Product Managers.
Summary
I successfully interviewed for a Staff Software Engineer position in Systems Infra at LinkedIn, Bengaluru, and received an offer after completing seven rounds of interviews, including multiple coding challenges, system design, and a hiring manager discussion.
Full Experience
My interview journey at LinkedIn for the Staff Software Engineer role in Systems Infra, Bengaluru, involved a total of seven rounds, including two re-do rounds for coding and system design. My background is B-Tech CSE from a Tier-1 college, with 5 years of experience.
Round 1: Phone Screening
This round started with a 20-minute discussion about my past projects and resume. Following that, I was given a Data Structures & Algorithms problem. We also touched upon basics of Java, OS, and Computer Networks. I received strong hire feedback as I completed the problem optimally and answered all CS basics.
Round 2: Coding-1
I faced two coding problems in this round. I was able to solve both problems, but my approach for the second problem differed from the standard LeetCode solution, and the panel was not entirely satisfied. This resulted in a weak hire feedback.
Round 3: Coding-2
This round also had two coding problems. I was able to complete both problems with 15 minutes remaining and received strong hire feedback.
Round 4: High-Level Design (HLD)
The problem presented was about designing a system for "Top n articles shared". It was a highly interactive discussion where I explained concepts like Count-Min Sketch, using maps and heaps, and how MapReduce and Spark jobs could be utilized. I received strong hire feedback.
Round 5: Hiring Manager (HM)
This round involved a detailed discussion on one of my past projects, where significant technical depth, product, and business impact were explored. I also answered standard behavioral questions, including "Why LinkedIn?". The feedback was strong hire.
After a week, HR informed me that I needed to redo a coding round and an HLD round onsite. HR explained that the HLD redo was requested by the HM, who wanted a more senior panel from the system's infra team to conduct it.
Round 6: Coding (Redo)
In this redo coding round, I was given two problems. I successfully completed both within 10 minutes to spare, earning strong hire feedback again.
Round 7: High-Level Design (Redo)
The second HLD redo round focused on designing a key-value storage system with get(), put(), and delete() operations. This was a deep infra-level discussion, covering B-trees, LSM trees, SSD writes, internal fragmentations, write amplification in disks, compactions in LSM, layered Bloom filters, and database recovery using WAL. I received strong hire feedback.
A week later, HR contacted me with the good news of an offer!
Interview Questions (8)
Given the root of a binary tree, turn it upside down and return the new root. You can only flip a binary tree if it is a 'left-only' tree where every node either has no children or only a left child. In the upside down tree, the original right siblings of a node become the new left children, and the original parents become the new right children.
Design a system to efficiently find the top N most shared articles.
Suppose you are at a party with n people labeled from 0 to n - 1 and among them, there may exist one celebrity. A celebrity is someone who is known by everybody else but does not know anybody else. You are given a helper function knows(a, b) which returns true if a knows b, and false otherwise. You need to find the celebrity.
Design a key-value storage system supporting get(), put(), and delete() operations.
Preparation Tips
My preparation largely leveraged the LeetCode community, which was instrumental in helping me get ready for the interviews. I hope sharing my experience can now give back to the community.
Summary
I recently completed the interview process at LinkedIn for a Software Engineering role, with 2.5 years of experience. The process involved a phone screen followed by four onsite rounds, covering Data Structures & Algorithms, System Design, and a Managerial discussion. I'm currently awaiting final feedback for the onsite stages.
Full Experience
My interview journey at LinkedIn for a Software Engineering role, with 2.5 years of experience, began with a Phone Screen. This round started with introductions and a deep dive into Operating System concepts, alongside a thorough discussion of my past projects and the challenges I encountered. I was then presented with a medium-level LeetCode problem involving range-based binary search, which I successfully solved, including follow-up questions. I received a 'Strong Hire' feedback for this round.
The Onsite Interviews comprised four distinct rounds:
1. DS & Algorithms (Round 1): I faced a hard stack-based problem, where I unfortunately couldn't complete the full solution. This was followed by a medium-level heap problem, which I solved with code and addressed all follow-up questions. My self-assessment for this round was 'Lean Hire / No Hire'.
2. DS & Algorithms (Round 2): This round presented a medium-to-hard N-ary tree problem, which I tackled with multiple follow-ups, answering all of them. Subsequently, I solved a sliding window problem, successfully handling all follow-ups. I rated my performance here as a 'Strong Hire'.
3. System Design: I was tasked with designing a key-value based system. This led to an in-depth discussion on its internal architecture, strategies for append-only log file management, log compaction techniques, and various disk cleanup strategies. I felt I missed 2–3 follow-up questions in this round, leading to a 'Lean Hire' self-feedback.
4. Managerial Round: This round involved a deep dive into my past project experiences. We also discussed Redis internal architecture, and I answered several behavioral questions. Additionally, I was questioned on SQL and indexing. I felt my current project lacked scalability, and the interviewer seemed unimpressed with my past project experience, resulting in a 'Lean Hire / Hire' self-assessment.
I completed all my onsite rounds last week, but as of now, I've only received feedback for the phone screen. I am still awaiting the final decision regarding my overall performance.
Interview Questions (1)
The task was to design a key-value based system. This involved an in-depth discussion on its internal architecture, append-only log file management, log compaction, and disk cleanup strategies.
Summary
I interviewed for a Senior Software Engineer role at LinkedIn within the Systems Infra team. Despite strong performance in Data Structures & Algorithms rounds, I received a rejection due to feedback regarding the structure of my system design discussions and the perceived scale of my previous startup experience.
Full Experience
Round 1: Data Structures & Algorithms
This round was postponed multiple times. The questions included:
- Finding K points nearest to the origin in 2D space. I solved this in 20 minutes. The problem was then extended to find K nearest neighbors to any arbitrary point in 2D space, where I discussed an approximate N-nearest neighbor approach.
- A problem similar to LRU Cache, though I don't recall the exact specifics of the question.
Round 2: Data Structures & Algorithms
This round was also postponed multiple times. The questions were:
- A problem similar to finding the diameter of a tree with 'n' children.
- Checking if two linked lists merge. For lists without cycles, I proposed checking if their endpoints are the same. For lists with cycles, I discussed that both should have cycles, and a point on the first cycle must be present in the second. I also extended this to figuring out the cycles and their starting points.
Round 3: High-Level Design (HLD)
I was asked to Design a Key-Value store. I approached this by starting with the purpose of the store, then discussing storage mechanisms, compute considerations, and sharding strategies. I didn't strictly follow common YouTube or system design structures in my discussion.
Round 4: Hiring Manager (HM)
This round involved discussions about my previous experience. I explained that while my prior startup had less scale, I built the product from scratch to profitability. I sensed the interviewer became disinterested due to the scale aspect. Other topics included design and tradeoffs, approaches, how I evaluate Proof of Concepts (POCs), and explaining a scenario where my design decisions were not adopted by my peers. I was also asked to Design a Job Scheduler.
The overall experience was good, though I ultimately received a rejection. The feedback indicated that my discussion structure needed improvement and I should work on projects with higher scale before reapplying for SDE3 roles at LinkedIn.
Interview Questions (6)
Given a set of points in 2D space, find the K points closest to the origin (0,0). The problem was extended to finding K nearest neighbors to any arbitrary point in 2D space.
The problem was similar to designing an LRU Cache, although I don't recall the exact specifics of the variation.
I was asked a question similar to finding the diameter of a tree, specifically one that could have 'n' children per node.
I had to determine if two linked lists merge. I discussed scenarios for lists without cycles and lists with cycles, including how to detect cycles and their starting points.
I was asked to design a Key-Value store. This involved discussing its purpose, storage, compute mechanisms, and sharding strategies.
I was asked to design a Job Scheduler. This round also covered discussions about my previous work experience, design tradeoffs, methods for evaluating Proof of Concepts (POCs), and resolving design disagreements with peers.
Preparation Tips
My preparation involved practicing previous LeetCode Data Structures & Algorithms problems and studying common High-Level Design questions. I am currently reading DDIA (Designing Data-Intensive Applications) and following 'hello-interview', which I find helpful for HLD interviews. However, HLD interviews still feel challenging and somewhat dependent on luck, or require extensive memorization of designs for various scales.
Summary
I interviewed for a Senior Software Engineer position focusing on Systems and Infrastructure at LinkedIn, which involved both phone screening and an onsite loop. Despite solving most coding problems optimally, I was ultimately rejected.
Full Experience
Phone Screening
The phone screen started with a deep dive into one of my projects. We then moved onto Java and OS-related questions. I also had a code review and enhancement task on a 10-line code snippet. For the coding problem, I solved a variation of the "Number of Islands" problem optimally.
On-Site
Coding 1
In the first coding round, I was asked two problems. First, I had to determine the number of connected components in an undirected graph, which I solved optimally. Second, I was challenged to design a hash map from scratch; this was a new problem for me, not found on LeetCode, but I managed to solve it optimally.
Coding 2
The second coding round also had two questions. The first was to find the number of subsets in a given array that sum up to a target. I solved the main problem optimally, but struggled with the follow-up, which involved handling negative numbers and duplicates in the input array, and couldn't solve it within the given time. The second question involved an N-ary tree: I had to prune all the leaf nodes and add them to a list, resulting in a list of lists. I solved this optimally.
For all coding questions, I dry ran my solutions and clearly explained both time and space complexities.
Hiring Manager (HM) Round
The HM round involved deep dives into 3-4 anecdotal experiences. I was also asked a real-world scenario question based on Kafka, which I unfortunately couldn't answer well. I made sure to ask some quality questions to the HMs at the end of the interview.
Complex Design (System Design)
This round focused on System Design, specifically designing a system for metrics aggregation and visualization. I felt I drove the discussion for most of this interview.
With 4.5 years of experience, I am absolutely gutted by the rejection. However, I remain determined and will continue grinding and pushing forward. Thanks to this community for the support.
Interview Questions (7)
A coding problem similar to "Number of Islands" with a slight variation, which I solved optimally.
I was asked to find the number of connected components in an undirected graph.
I was asked to design a hash map from scratch. It was a new problem not found on LeetCode.
Given an input array, I had to find the number of subsets that sum up to a target. The follow-up involved handling negatives and duplicates in the input.
I was asked to prune all the leaf nodes from an N-ary tree and add them to a list, with the output being a list of lists.
I was presented with a real-world scenario question related to Kafka and its applications/issues.
I was tasked with designing a system for metrics aggregation and visualization.