Linkedin Interviews

My interview process with LinkedIn started with a phone screen that covered both ML theory and light coding. I explained the attention mechanism and implemented an infinite data stream mean calculator using an incremental formula to avoid overflow.

For the AI coding round, I used an AI-assisted IDE to implement an LRU Cache data structure. I generated a Doubly Linked List with a HashMap, but the interviewer kept adding features, leading to over-engineering. I wasn't sure what was being evaluated in this round.

In the data structures and algorithms round, I discussed previous projects and validated a Binary Search Tree. I provided two solutions: an in-order traversal for O(N) time and a recursive approach for space optimization.

The ML fundamentals round focused on retrieval/ranking theory, imbalanced data, and model explainability. I demonstrated strong theoretical understanding, which the interviewer praised.

The system design round was challenging. I designed a Two-Tower Architecture for a Second Pass Ranker, but I made a critical mistake by using it for ranking instead of retrieval. I also incorrectly used softmax for a multi-label scenario, which should have been multi-label sigmoid heads.

Finally, the hiring manager round focused on product vision, behavioral questions, and my resume. While they complimented my diverse experience, they felt I needed to focus more on product-facing teams.

As someone with 3+ years of experience as a DS/MLE in a product-based company and a B.Tech from IIT (non-circuital), I went through a multi-round interview process for a Software Engineer role at LinkedIn. The process started with a screening round that included a DSA question, a probability question, ML fundamentals, and questions on Transformers. The full loop consisted of five rounds: an AI coding round with two problems, a DSA round with two problems, an AI fundamentals/data mining round, an AI system design round, and a hiring manager round with behavioral questions.

I recently went through the interview process for an SDE2 role at LinkedIn, India (Apps). I applied about a month ago, and a recruiter reached out. The entire process after the initial screening (TPS) was very swift, with the recruiter providing feedback within a day or two after each round. I have 4 years of experience and previously worked as an SDE2 at a top product company, unfortunately being laid off in August. I noted that they were not offering SSE for candidates with under 5 years of experience. Although I haven't received a formal offer yet, the feedback from all my rounds has been positive. I initially applied via LinkedIn's easy apply feature.

Round 1:
This round focused on Data Structures & Algorithms, where I was asked two coding problems.

Round 2:
Another coding round with two problems, one involving heaps and another focusing on Tries.

Round 3: System Design
This round was dedicated to System Design concepts, specifically around monitoring.

Round 4: Technical Communication
This round involved discussing one of my projects in depth, followed by standard technical communication questions.

Host Manager:
The final round with the Host Manager included a deep dive into one of my projects, several behavioral questions, and a High-Level Design discussion for a malicious/spam URL detection system, including how I would execute the project end-to-end.

I interviewed for a Senior Software Engineer (SSE) role at Linkedin in October 2025. The process involved multiple rounds, and despite strong performance in some areas, I was ultimately rejected.

Round 1 - Technical Problem Solving (TPS)

This round involved a mix of technical discussions and a DSA question. I was asked to:

• Discuss any issues I've found in systems during my work, such as performance bottlenecks or poor code quality.
• Share my mentoring experience.
• Explain software design patterns and their importance.
• Describe the CAP theorem.
• Differentiate between concurrency and parallelism.
• Determine the output of a given multithreading code snippet.
• Solve the "Diameter of a Binary Tree" problem.
• Design an API capable of handling 10,000 queries per second (QPS) for write traffic.

I received a "Hire" verdict for this round.

Onsite Rounds

Round 2 - Data Structures & Algorithms (DSA)

In this DSA round, I faced three problems:

• An adaptation of Insert Delete GetRandom O(1), specifically focusing on implementing a removeRandom method.
• A follow-up based on Insert Delete GetRandom O(1) - Duplicates Allowed.
• A problem conceptually similar to Number of Islands, but presented within a real-world story context.

I received a "Strong Hire" verdict for this round.

Round 3 - Data Structures & Algorithms (DSA)

This DSA round had two problems:

• Closest Binary Search Tree Value II: I could only develop an O(N) solution, while the interviewer was looking for an O(logN) approach using predecessors and successors.
• Intersection of Two Linked Lists.

The verdict for this round was "No/Lean Hire".

Round 4 - High-Level Design (HLD)

I was asked to design a notification system. This involved considering aspects like rate limiting for different notification categories (e.g., 5 marketing notifications per day per user) and handling user preferences. Additionally, there was a discussion on how I measure project success, including performance testing and metrics like p90.

The verdict for this round was "No/Lean Hire".

Round 5 - Hiring Manager (HM) & Behavioral

This round covered a mix of behavioral questions and another system design challenge. Behavioral questions included:

• My reasons for switching from my previous role.
• Differences I observed between my current and previous companies.
• My experience with ops work and on-call duties.
• A conflict I faced with management and how I resolved it.
• How I keep up with the tech industry, particularly during a career break.
• An interesting tech article I've read, where I cited Discord's blog on indexing trillions of messages.
• My technical growth over the past year.

The system design problem was to design a system to route leads to sales representatives. Key requirements included routing individual leads based on timezone and region, allowing the product team to configure rules, sales reps checking leads via UI or email, and lead scoring, all while handling 15,000 leads per day.

The verdict for this round was "Lean Hire".

Overall, the recruiter provided detailed feedback, indicating that my answers, particularly in the system design and depth expected for an SSE, were lacking. Despite the rejection, the process was smooth, and the feedback was appreciated.

My interview journey for the Senior Software Engineer (System and Infra) role at Linkedin, USA, involved several rounds.

1st Technical Screening Round

This round began with a coding question similar to "Number of Islands". Following the coding challenge, we spent about 30 minutes discussing my past projects. The interviewer also delved into OS basics, covering topics like processes, threads, semaphores, mutexes, PCB, TCB, heap, stack, and networking fundamentals.

I received a response after 8 days inviting me for the onsite rounds.

Onsite Rounds

1st Coding Round

This round involved a question based on N-Array trees. Unfortunately, I don't recall the exact problem statement.

2nd Coding + AI Round

I was presented with a code snippet and asked to implement a specific function. The problem was related to topological sorting, somewhat reminiscent of "Course Schedule" type questions.

This round was quite chaotic. The interviewer seemed to have no idea how to conduct it, which unfortunately wasted about 20 minutes trying to figure out which AI assist tool we were supposed to use. I felt this round deserved a re-do due to the disorganization, but I knew that wouldn't be an option.

3rd System Design Round

This round focused entirely on system design. The problem involved designing a metrics aggregator and a monitoring system.

4th Host Manager Round

The host manager round started with a discussion of my past projects, including questions about projects I was particularly proud of. There were follow-up questions about the technologies and workflows I utilized, technical challenges I faced, and design choices I made. Standard behavioral questions were also included. Towards the end, I was given a system design-like question: "How to migrate data from one Data centre to another," with specific conditions applied.

Overall, it was a good experience. I'm now waiting to hear about the final outcome.

I recently went through an interview for a Staff Software Engineer position at LinkedIn in the US. The interview started with a quick 5-minute self-introduction, followed by 20 minutes dedicated to behavioral questions. The main technical part involved a coding problem where I had to design and implement a Max Stack data structure ensuring all its core operations, such as push, pop, top, peekMax, and popMax, maintained a worst-case time complexity of either O(1) or O(log n).

I started the interview with an introduction. I felt the interviewer was a bit nervous and seemed to have just come off another meeting.

We then moved on to CS fundamentals. I answered questions about Virtual Memory and Process vs. Thread perfectly. For Database Normalization, I mentioned the read/write trade-off and deduplication, but the interviewer didn't seem satisfied. When asked how to implement a hashmap from scratch, I was caught off guard and couldn't remember, providing an incorrect answer. This was a missed opportunity.

Next was the coding section. I was given the problem Nested List Weight Sum II, which had four follow-ups. I handled the coding and dry run almost perfectly in one go.

• First, I solved it with a two-pass DFS approach.
• Then, a single-pass BFS.
• For the third follow-up, I was asked for a single-pass DFS (ignoring call stack space and optimizing space), which I tackled by storing level sums in a hash map.
• The last follow-up was for a single-pass DFS with constant space, using the formula (max_depth + 1) * unweighted_sum - normal_weighted_sum. I needed a hint for this one.

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.

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.

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.

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. 🚀

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!

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.

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.

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.

I applied for an SSE position at LinkedIn via LinkedIn Easy Apply, having 5 years of experience.

Screening Round:

This round began with a discussion about one of my projects. Following that, I tackled a coding problem which was Nested List Weight Sum II (https://leetcode.com/problems/nested-list-weight-sum-ii/description/). I was able to solve it quickly with an optimized approach. We also covered standard questions on OS, CN, and Java basics. The feedback was a 'Strong hire' for my performance.

The first coding round presented two problems: All O(1) Data Structure (https://leetcode.com/problems/all-oone-data-structure/description/) and Binary Tree Upside Down (https://leetcode.com/problems/binary-tree-upside-down/description/). I received 'Weak Hire' feedback, primarily because my solution for the second problem was not identical to the LeetCode solution, and the panel found it difficult to understand my approach without listening properly.

In the second coding round, I solved Max Consecutive Ones III (https://leetcode.com/problems/max-consecutive-ones-iii/description/) and a standard topological sorting problem. I was able to solve both problems, leading to 'Strong hire' feedback.

This round focused on discussions about my past projects and my motivations for wanting to join LinkedIn. I had a compelling project to explain that involved a good amount of business, product, and technical complexity. The feedback was 'Strong hire'.

The HLD problem was to design a system for handling Top K articles shared over various time intervals (1 min, 5 min, 1 hour, 24 hours). I discussed using techniques like count-min-sketch, maps, and heaps, explaining the drawbacks of each. I addressed counter increment lock contention issues by proposing aggregations at the API gateway and Kafka consumers to reduce database operations. For the 24-hour handling, I suggested MapReduce or Spark. I also identified system bottlenecks like duplicate Kafka events and database recovery, referencing standard DDIA concepts. My approach was similar to the one found here: https://serhatgiydiren.com/system-design-interview-top-k-problem-heavy-hitters/. However, I received 'Weak hire' feedback, with the panel criticizing aggregations at the API gateway as business logic, despite discussing tradeoffs during the interview.

After a week, HR informed me about the two 'Weak hire' feedbacks and offered me one more chance, consisting of another coding and HLD round.

In this second attempt at a coding round, I faced two problems: Insert Delete GetRandom O(1) - Duplicates allowed (https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/description/) and Find the Celebrity (https://leetcode.com/problems/find-the-celebrity/description/). I solved both completely with 15 minutes remaining, which I considered a 'Strong hire' performance from my end.

This round involved designing a KV storage system, specifically considering only a single VM with disk and equal get, put, delete operations. I started by explaining why MySQL wouldn't be suitable due to B+tree issues and internal fragmentation. I then detailed an LSM-based approach, discussing segments, layered Bloom filters, segment compaction, internal fragmentation, and write amplification in SSDs, essentially navigating through the entire LSM concept. We also had a good discussion on database recovery after a crash using WAL and disk. The panel then changed the problem statement to handle 10GB blob values. I adapted my approach to convert large files into smaller chunks based on disk free space, with similar changes to caching and pointers between chunks to reduce disk seeks. The panel wasn't satisfied with this, and the interview ended abruptly as we were already running late. Given the high bar at LinkedIn Infra, I considered this a 'Weak hire' from my perspective.

After another week, I tried reaching out to HR but received no reply, which I take as a rejection. The grind continues.

I had my technical screening for a Senior Software Engineer position at LinkedIn. The interview began with a 20-minute discussion where the interviewer asked me several questions about my current job and projects. Following that, I was presented with two coding questions. Both problems were quite familiar to me, and I was able to approach them confidently. I am now waiting to hear back about the outcome of this round.

About me - 6 YOE (PBC)

Screening Round/Elimination Round: Some System design related questions. eg: Difference b/w write though and write back cache. Which DB to use when. Some programming related questions. And a multi-threading question on synchronization. 1 DSA question: Course schedule II

On-Site Rounds:

Round1: 2 DSA Questions:

1. Find Celebrity Problem
2. Some Tree related problem

Round 2: 2 DSA questions:

1. It was some DP related question that I don't remember exactly. Somrthing similar to edit distance.
2. Graph related questions, where we need to find minimum steps to reach soource to destination

Round 3: Design Round: Design Linkedin Post and comment functionality. Later on extended it to add analytics to it.

Round 4: HM Round: Senario based questions. And current project related details.

Overall really good experience and process was also really smooth. I don't know i'll be selected or not. But considering this as my first FAANG level interview it felt really nice to me. And i learned a lot as well from the interviwers.

Screening Rounds

Round 1(Coding):

• Behavioural questions: Why do you want to switch, why linkedin, Discussion on one of the projects.
• Coding Problem: https://leetcode.com/problems/all-oone-data-structure/

Round 2 (Staff Host Leader)

• Behavioural questions similar to above with examples of any project
• Leadership questions such as explain any complex project you have led

Onsite

Coding Round 1:

• Tree has keys and values, values represent sum of this and child node values
  When merging - absent branches should be created, and values for existing branches are summed
  Keys are unique among child nodes of a single parent
  Child nodes could be stored in any order

  // #     Root:10
  // #     /  |  \
  // #    A:2 B:2 M:6
  // #     |  |
  // #    L:2 L:2
  // # Target tree T
  // #      Root:13
  // #     /  |   
  
  // #    A:4 B:3 D:6
  // #    /        
  
  // #.  L:4        M:6
  // # Result tree RT
  // #          Root:23
  // #      /     |   \    
  
  // #    A:6    B:5   D:6  M:6
  // #    /       |     |
  // #   L:6     L:2   M:6
  

Coding Round 2:

• You have given users and its direct connections. For a given two users S and P, find minimum degree of connection. Degree of directly connected users is 1.
  Expected ans: Bidirectional bfs
  Follow up: Find the path

Staff Software Design and Architecture Round:

• Design metrics aggregation system

Staff Infrastructure Design and Implementation:

• Design a system which takes stream of linkedin posts and form a inverted index of all the words in the post. The user will query a list of words, you have to return all the post ids which has all the given list of words.

Result: Rejected

Application - applied on linkedin itself, post which recruiter reached out.

Total Rounds - 6

Phone screen
Two DSA question
1. Similar to https://leetcode.com/problems/bulb-switcher.
2. https://leetcode.com/problems/shortest-word-distance-ii.
Gave optimal answer for both , questions on resume. Got result on the same day for moving to onsite.

Round 1 - DSA
1. Question related to turning tree upside down with 0 /1 right child.
2. Question similar to number of island.
Solved both optimally, interviewed tried to confuse with an non existing case, got a little confuse but then cleared it with interviewer they were satisfied.

Round 2 -DSA
1. max consecutive one , similar to this with wrap around follow up
2. falling leaves question https://leetcode.com/problems/find-leaves-of-binary-tree/
Solved both optimally along with time complexity discussion, interviewer was satisfied.

Technical Communication - was asked to explain a project we did and went into details along with follow ups and trade off discussion, most interesting and had a good discussion.

System Design - Design Calendar, discussed mainly about API, also asked SQL query (I wasnt prepared for this hence it took some time to figure out), API discussion and DB Schema design took sometime couldn’t discuss HLD much.

Hiring Manager - This round was interesting and had a nice discussions around the probleam faced during work, some behavioral questions, discussed details around different databases and its usecase, HM also gave me a problem to just figure out how would I approach to it, I didn’t have to do all things on my own and can ask for help, such as which all team will you reach out , how to structuure approaches doing POCs, and other usual behavioural questions.

Recruiter was super responsive and replied quickly on any doubts, the experience was quite good with new learnings. All the best whoever is appearing for interviews, just giving back to the community.
Except System Design everything was really good, system design I could have done better. Overall process took around 15 days.

Result Awaiting

There were two interviewers, both asked for intro and one project detail each. One asked a design related follow-up which I fumbled. Each gave one DSA problem both easy (Again fumbled both)

1. A variation of https://leetcode.com/problems/can-place-flowers/description/ in place of flowers it was people

2. Given the standard mapping from English letters to digits on a phone keypad (1 → "" 2 -> a,b,c 3 -> d,e,f 4 -> g,h,i 5 -> j,k,l 6 -> m,n,o 7 -> p,q,r,s 8 -> t,u,v 9 -> w,x,y,z), write a program that outputs all words that can be formed from any n-digit phone number from the list of given KNOWN_WORDS considering the mapping mentioned above. KNOWN_WORDS= ['careers', 'linkedin', 'hiring', 'interview', 'linkedgo'] phoneNumber: 2273377 Output: ['careers'] phoneNumber: 54653346 Output: ['linkedin', 'linkedgo']

Was able to come up with approaches for both but was a bit slow in identifying edge cases, there was no way to submit the problems and run against test cases on LinkedIn platform(they use coderpad). Asked to specify space and time complexity for both.

Hi Leetcoders, I am posting my interview experience with LinkedIn India for the Staff Software Engineer role. For the Staff role, they have total of 6 rounds: 1 Screening and 5 online rounds

Here is the breakdown of all the rounds:

In this round, Firstly, I was asked to give my detailed career intro along with leadership/project related questions:

1. Conflicting situations faced in any critical project
2. Impactful project from which I was able to move out to other project with minimal disruption

Few follow-ups were there and this discussion lasted for around 20 mins

Then, I got a LC Hard DSA question : https://leetcode.com/problems/max-stack/

I discussed 2-3 most optimal approaches and the interviewer agreed on one of the approaches to code it for all the helper methods along with discussion on Space and Time Complexity. Also, I was asked to dry run on a pre-written TC.

Rating : Strong Hire

Q1: https://leetcode.com/problems/minimum-window-substring
The problem was extended to a condition when the source string is wrapped around.

Q2: Shortest path between LinkedIn connections. An adjacency list is given, a source and a target. Find the connection distance between source and target. Print the path as well.
I discussed the optimal solution : Bi-directional BFS and coded for the same.

Rating : Strong Hire

Q1: https://leetcode.com/problems/word-ladder
I gave the most optimized O(M*N) approach inspired by the below link:
https://leetcode.com/problems/word-ladder/submissions/1595132398

Q2: https://leetcode.com/problems/shortest-word-distance-ii
Gave the optimal 2-pointer approach.
Extension: For the scenario if one string's occurences are less than other, used binary search for the more frequent string.

Rating : Strong Hire

Initially, this round started with project and leadership based questions. Don't remember the exact questions, Apologies.
Next, the interviewer covered the most complex project I recently led and covered about the security aspects and challenges faced. There were multiple follow-ups to understand my roles and responsibilities working as a tech lead.

Next, I was given the below system design problem:

Design a flexible in-memory cache with customizable capacity and eviction policies.

The cache should allow users to define:

1. Capacity: Specify how much data the cache can hold based on memory resources and data size.
2. Eviction Policy: Choose strategies for removing items when the cache is full, such as Least Recently Used (LRU) or Lowest Priority.

This flexibility ensures the cache can be tailored to meet specific requirements, balancing resource usage and performance.

Once the LLD created was agreed with the interviewer, it was extended from HLD perspective for multiple nodes in distributed system setup covering all the challenges and other adhoc scenarios like hot key issue for a write-heavy setup. Also, discussion went around few Redis related internals.

Rating : Hire

This is mostly a behavioral based round for Staff role. It covered 8-10 scenario questions with internal follow ups. Questions were as follows:

• How do you define a quality product/system?
• Describe your strategy regarding code reviews
• Talk about a project that had many junior engineers and how I kept the project quality high/ If your team keeps growing and you get more junior engineers, what do you do?
• As a hypothetical situation, Imagine you join LinkedIn on a massive team that owns a legacy application. The application lacks adequate testing and monitoring and has slow response times. Consumers complain about this. Deployment of the application often contains bugs. What efforts would you do as a Staff SWE?
• Rank the following in terms of priority: bugs, no testing, no monitoring, slowness. What do you tackle first? How do you eventually turn this into micro services?
• What do you look for when determining the success of a service?
• What are your principles of mentorship? How do you manage technical and non-technical mentorship?
• Talk about a time where you helped grow engineers
• Few questions which were aligning with the LinkedIn values. Don't remember the exact questions.

Note: Please be well-versed about Linkedin values.

Rating : Strong Hire

This round started with an elaborate introduction of both me and the interviewer.

Questions were as follows:

1. Talk in detail about the most complex and challenging project I led in the recent times which had a very large scale. I framed my answer step-by-step as follows (along with few follow-ups from the HM):
   -> Team and My role
   -> Customer Problem & Business impact
   -> Key architectural decisions led/taken by me
   -> Biggest challenges faced and how did I overcome
   -> How did I maintain timely execution of the project
   -> Changes in reqs/unexpected blockers
   -> Ensuring alignment with stakeholders
2. Why looking for change? Why LinkedIn?
3. Describe a situation where you showed operational excellence.
4. Describe a situation where you suggested improvements in the project which other engineers in the team could leverage from.

Then at the end, he threw a HLD problem for designing a LinkedIn internal notification system which can handle a very large scale.
There were few cross-questions regarding the different internal microservices and Kafka being used for async handling.
This just had 10-15 mins at the end. Luckily, I was able to create the HLD diagram covering all the components.

Verdict : Selected for the staff role after a week.

Compensation details :
Base salary: 88 LPA
Target bonus : 13.2 LPA (min 15%)
PF : 4.25 LPA
RSU: 350k for 4 years, 75.6 LPA
Relocation bonus/services: ~5 L
Net CTC per year : 1.85 Cr PA
YOE : 10
Current CTC : 63 LPA (Microsoft : Senior SWE)

Had another competing offers from Atlassian and Salesforce (~1.4 Cr PA), but finally I accepted the LinkedIn offer due to better role and compensation.

Thanks to the Leetcode community for helping during my preparation and it's my time to give back to the community. Cheers!

I recently completed first round of interview with LinkedIn, where I was asked to solve the following problem.

Given a list of node integers, I have to calculate the total weights of the list. The weight calculated as follows, {{1,2},2,{1,2}} = 1x1 + 2x1 + 1x1 + 2x2 + 2x2 = 8 i.e. innermost depth multiplier is 1, in this case it is {1,2} & {1,2} and a layer outer to that multiplier is 2, in this case it is 2

similarly for, {{1,2}, 3, {4, {6}, 5}} = 6x1 + 4x2 + 5x2 + 3x3 + 1x2 + 2x2

I know I have to solve maxDepth first (by first recursion) and then use recursion (second) by reducing the depth by 1 on each inner level. But, instead of implementing the solution I tried to simplify it further by calculating the weight and depth in single recursive call. Eventually timed out. Feeling sad for missing this simple problem which I know can be solved in less than 10 mins. I actually solved the problem after the interview in 5 mins but of no use. Not sure if it is the only approach or any other better approach is available.

// implementation of NodeInteger

public class NodeInteger { // returns true if this node has integer rather list public isInteger();

// returns the integer this node holds public getInteger();

// returns the list of child NodeIntegers public getList(); }

I was asked this question in the interview: Given the standard mapping from English letters to digits on a phone keypad (1 → "" 2 -> a,b,c 3 -> d,e,f 4 -> g,h,i 5 -> j,k,l 6 -> m,n,o 7 -> p,q,r,s 8 -> t,u,v 9 -> w,x,y,z),

write a program that outputs all words that can be formed from any n-digit phone number from the list of given KNOWN_WORDS considering the mapping mentioned above.

KNOWN_WORDS= ['careers', 'linkedin', 'hiring', 'interview', 'linkedgo']

phoneNumber: 2273377 Output: ['careers']

phenoNumber: 54653346 Output: ['linkedin', 'linkedgo']

Solution:

public class WordFinderFromPhoneNumber {

    private static final String[] KEYBOARD = {
        "",     // 0
        "",     // 1
        "abc",  // 2
        "def",  // 3
        "ghi",  // 4
        "jkl",  // 5
        "mno",  // 6
        "pqrs", // 7
        "tuv",  // 8
        "wxyz"  // 9
    }; // Already Given

    private static final List<String> KNOWN_WORDS = Arrays.asList(
        "careers", "linkedin", "hiring", "interview", "linkedgo"
    ); // Already Given

    private TrieNode root;

    public WordFinderFromPhoneNumber() {
        root = new TrieNode();
        buildTrieNode(KNOWN_WORDS);
    }

    public List<String> wordsFromPhoneNumbers(String phoneNumber) {
        List<String> result = new ArrayList<>();
        Map<Character, Set<Character>> digitToCharMap = new HashMap<>();

        for (int i = 2; i <= 9; i++) {
            char digitChar = (char) (i + '0');
            for (char ch : KEYBOARD[i].toCharArray()) {
                digitToCharMap.computeIfAbsent(digitChar, x -> new HashSet<>()).add(ch);
            }
        }

        backtracking(phoneNumber, 0, digitToCharMap, result, root);
        return result;
    }

    private void buildTrieNode(List<String> words) {
        for (String word : words) {
            TrieNode curr = root;
            for (char c : word.toCharArray()) {
                curr.childrens.putIfAbsent(c, new TrieNode());
                curr = curr.childrens.get(c);
            }
            curr.word = word;
        }
    }

    private void backtracking(String digits, int index, Map<Character, Set<Character>> map,
                              List<String> result, TrieNode curr) {
        if (index == digits.length()) {
            if (!curr.word.isEmpty()) {
                result.add(curr.word);
            }
            return;
        }

        char digit = digits.charAt(index);
        if (!map.containsKey(digit)) return;

        for (char letter : map.get(digit)) {
            if (curr.childrens.containsKey(letter)) {
                backtracking(digits, index + 1, map, result, curr.childrens.get(letter));
            }
        }
    }

    private static class TrieNode {
        Map<Character, TrieNode> childrens = new HashMap<>();
        String word = "";
    }
}

Even after giving this solution, got the rejection email.

Hello! It's time for me to finally give back to the community.

Some stats:
2 yoe
~300 leetcode questions
Applied through referral

Phone Screen:

https://leetcode.com/problems/maximum-subarray/
https://leetcode.com/problems/maximum-product-subarray/description/

Onsite:

Coding 1:

https://leetcode.com/problems/max-consecutive-ones-iii/description/
With multiple follow-ups.

Needed a few hints with the follow-ups. At the very end we ran out of time so I had to answer them verbally.

Technical Communication:

I felt like my past projects were very lackluster. My last role was very domain specific, and the project itself was adding a new configuration to a pipeline that was already established by rock-star engineers before me. Because of this, the design choices I made were very straightforward with little to no tradeoffs to consider. I talked about the infrastructure of the pipeline, and the data flow that is involved with the new configuration.

When asked what I would change I talked about possible modifications to the infrastructure and the effect it would have. But with the tradeoffs considered I would stick to the original design of the engineers before me.

Coding 2:

https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/

In asking clarifying questions I inadvertently increased the scope of the question and had to implement something extra. I needed a few hints but was able to complete the question. We ended with 15 minutes to spare and I was a bit confused as I was expecting 2 questions. Finished the rest of the interview chatting about linkedin and their experiences.

HM:

Was asked behavioral questions and data processing questions. They asked some high level System Design question related to metrics gathering. At the very end of the interview they kept talking to the point where the next round of interviewers came in and had to cut things short. This was my favorite interaction in the entire interview, as I really enjoy people sharing the things they’re passionate about.

System Design:

Design a calendar. I was most nervous about this, as it was my first time in an official System Design interview. I think I spent a little too much time on the high-level API’s and gathering requirements, where at the end of the interview we didn't get a chance to discuss too much into scalability (which I think is the fun part). But overall I was able to get a decent high level design that solved the problem, and was able to answer all of their questions.

Final Result: Offer

I got really lucky that I was relatively familiar with the questions I received. All interviewers were very kind and I felt like I vibed with all of them. If I had to prep again I would focus on the top LinkedIn tagged questions, and the rest on System Design. I did mock interviews for all of the interviews above categories and it really gave me confidence on the big day.

For those that were impacted by layoffs don't give up! End of last year I was laid-off and was driving home from work crying. I felt like a failure and my confidence and self-worth was at an all-time low. But reading everyone’s posts on their interview grind gave me the motivation to keep on going. If anyone reading this is going through anything similar I want you to know that with enough time and luck things will eventually get better.

Recently a Linkedin recruiter reached out on Linkedin for a SSE role in their infrastructure team.

Round 1

Questions on past experience - discussed about one project in depth.

Questions on CS fundamentals - paging, thrashing, threads, process, mutex, semaphore

Questions on Java - final, finally, finalize, GC

DSA: https://leetcode.com/problems/shortest-word-distance-ii/

Verdict: Rejected. Messed up the implementation on coderpad - interviewer expected successful compilation and execution.

Total duration 1 hour. First 30 mins introduction and behavioral round. Later part coding question

Round 1 : Preliminary Screen Round

Discuss Theory Question Like HTTP Methods POST, GET, PUT and Delete WHy cannot we use POST to fetch data and GET to send data, what happens?

Discuss Accessibility.

What is the Output of the following code?

let Foo = function(a) {
    function bar() {
        return a;
    }
    this.baz = function() {
        return a;
    };
};
Foo.prototype = {
    biz: function(a) {
        return a;
    }
};

Follow up on output classes and constructor.

Final Code this in coderpad using html, css: https://imgur.com/a/table-free-layout-Rwnqk

Round 2 : product and technical taste hybrid

1. Discuss the Projects i have done
2. Advantages of typescript? would you move your application to typescript.? how would you convience people
3. Explain any project end to end. Challenges face and how do you handle.
4. Technical website/forums usually visited? online and offline.
5. Interaction design, visual design, information acrichture, which is important when building ui
6. When to write UT and when to not. any scenario when not writing UT is good?
7. If you have to change anything in linkedlin
8. techinal problem i stuct at and how do i solve it
9. How to Choose a Framework?
10. Any leadership initiative taken in terms of technical.

Round 3 : Pragmatic UI

Design calculator focus on functioality only, skin memory m mc things from screen https://drive.google.com/file/d/0B7MB0kH2SO8MZzdGM1lNUklqaHc/edit?resourcekey=0-LUdqEyhWmAlQhDmZFvYew

**Follow up Question ** follow up how will you implement this behaviour, this old time calculator

• [key] | display ---------+--------- {{init}} | 0 [1] | 1 [2] | 12 [+] | 12 [3] | 3 [4] | 34 [=] | 46

Round 4 : Coding DSA

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.

2. https://leetcode.com/problems/all-oone-data-structure/description/ Same to same no change

Round 5: System Design and Architecture (UI Focus)

Discuss design for linkedln live comment section..How will you design comment section of Linkedln Live/ Ig live comment section. Discuss Scalibility How will system work if user join at mid of the live video. How things will work if a user has slow connectivity.

Round 6: Host Leader(Hiring Manager)

Discuss Projects I have done, in each company what is my role. How would you handle multiple responsibility And other Standard hiring manager questions based on the work i have done.

Last One system design question: How will you design recommendation system for Linkedln Jobs. (Both Frontend + Backend). Focus more on backend.

OA - 2 or 3 Med/Hard problems. Couldn't remember

Screening :

Some OS & Java fundamentals and 2 DSA :

1. Similar to : https://leetcode.com/problems/bulb-switcher/description/
2. Given list of words and a phoneNo. return the words which can be formed using given phoneNo. Pretty standard one.

CA1 :

1. Exactly : https://leetcode.com/problems/all-oone-data-structure/description/
2. Similar to https://algo.monster/liteproblems/366 . But it was N-ary tree instead of Binary tree.

CA2 :

1. No of Island problem. Little twisted.
2. Celebrity Problem

Design :

Design Metrics aggregation System

HM :

Past experiences mostly and behavioral questions.

Been more than 3 weeks and not getting any response from HR. So I consider it as a Reject.

Hi All,

My interview took place 2 weeks back and I did not hear back anything from my recruiter even after follow up so its a reject.

Coding 1:

1. LCA of BST
2. Get Random values in a list [implement add, getRandom, deleteRandom]

Coding 2:

1. Find if its a same tree or not
2. Shortest distance between LinkedIn Connections

Design: Top K system with 5 mins, 1 hr and 24 hrs window

TC: Challenging project, Resume related questions

HL: My day at work, Challenging project, hypothetical questions

Linedkin Recruiter reach out to me via linkedin, The entire process took 1 month exactly consist of 1 Intro round, 1 OA (online assesment), 1 telephonic, 4 Onsite Round(Online Rounds).

Current stack : SDE-3 (Golang/Backend Engineer)

Intro Call: HR asked questions related to profile and looking out for candidates with good system knowledge.

Telephonic Round: Asked 1 Coding Question, It is java specific role so they asked java questions mostly oops related

OA: Hackerrank Assesment having 3 questions, able to solve 2 completely and 1 partially with 2 cases going TLE.

Onsite Rounds:

Coding Round1: Question 1: given the logs find out time taken by each function, inclusive and exclusive time Question 2: LCA of BST.

Feedback: Hire

Coding Round 2: Question 1: Merging 2 B+ tree Question 2: Djikstra Algorithm, initially it was solved with Queue because it was considered to be unit distance and later they have given distances.

Feedback: Not able to solve 1st question entirely.

System Design Round: Asked to implement Key Value Store, Discuss FR and NFR and able to come up with approach where storing the data in the Ram and for HA/Backup keeping it in FileStorage. Have been asked a good follow up question. Feedback: Hire - Average rating

Hiring Manager Round: 15 mins late to interview and gave the negative feedback stating didnt have depth knowledge of the things worked on.

Hire: Not Hire

Note: Just use linkedin tag questions for round 1 and round2. they are enough but they usually give it with class and method signature to make it tricky. Focus on Designing the system from scratch. and All the best if your hiring manager is not good fit for the role :P.

Feedback: Not Hire. Feeedback receieved that they are looking out for strong hire candidated. From my side I was not able to do good in 2nd coding round.

Wanted to share my experience for SSE interview at LinkedIn India position. Got rejected at phone screen round even after solving both of the DSA question within time frame with optimal solution, explained the code thoroughly with test case. Feeling disheartened and still not able to believe I got rejected, didn't understand the reason why I got rejected even after performing good in the round. Below are the question asked, hope it will help others:

Role Applied For: Software engineer, Frontend YOE: 2 years

I recently went through the interview process for a frontend software engineering role at LinkedIn, and wanted to share my experience in case it helps someone else.

There were 7 rounds in total, including the initial phone screen. I applied via referral and heard back from HR within a week. I asked for a bit of prep time, so the first interview was scheduled the following week.

Round 1: Phone Screening Round

• This was one of the trickiest rounds. The panel initially asked about the differences between HTTP requests. What seemed simple at first quickly turned more complex, and we ended up discussing idempotency and browser caching in GET requests, among other things.

• After this discussion, we quickly moved on to machine coding, where I was asked questions about prototypical inheritance, closures, constructor functions, and the concepts of bind, call, and apply.

• Then, I was asked to implement a memoization higher-order function (HOF).

I received a call from HR the next day confirming that I had cleared this round, and there would be 6 more rounds.

Round 2: Browser JavaScript Round

This one was mostly about core browser + JS knowledge.

• This round focused on JavaScript, particularly DOM manipulation and browser-based JS. The interviewer quickly went into depth and tested my understanding of core concepts throughout
• Q1: Re-implement the includes method for any DOM node’s class list. Discussed good edge cases around it
• Q2: Efficiently parse query strings from a given URL.

The interviewer dug deep into time and space complexity, even for built-in methods. Definitely worth brushing up on browser APIs and their internals.

Round 3: Product Taste

No coding here — just a product and thought process round.

• This round was a mix of product and technical discussions, with no machine coding involved. The goal was to assess my understanding of how a product works and whether I can think beyond just the technical aspects.
• I was asked questions about good testing practices, working style etc
• One interesting question: What’s a feature you think LinkedIn is missing?

Round 4: UI focused DSA

There were two questions in this round.

• The first question involved extending the String prototype in JavaScript and implementing a custom function for repeating any string n times.

"abc".repeat(3) should give "abcabcabc"

• O(n) was very obvious and she asked me to think about O(log(n)) only
• The second question was about efficient DOM tree traversal. Given two nodes node1 and node2, check if node2 is a descendant of node1 somewhere in the DOM. Focus was on efficient tree traversal and edge cases

Round 5: Frontend system design

This one was more open-ended and definitely fun.

• The initial task was to display a blip on a world map every time someone joins LinkedIn.
• I mentioned choosing between polling and sockets. The interviewer made sure I wasn't just using jargon and spent a good amount of time evaluating whether I was making a calculated choice between the two.
• After I finished the basic solution, the interviewer added a twist — we could now fetch data only every 5 minutes, but still had to show a real-time view on the map. It made things more interesting, and the round turned into a collaborative problem-solving session, which was actually pretty fun

Round 6: Pragmatic UI

Tough but interesting round — very real-world.

• The task was to design a filters section like on Amazon, handling fetching and storing filters, rendering and toggling them, syncing filter state with the UI, making efficient POST requests on changes
• Discussed debouncing in detail
• Honestly, it was difficult to think through and implement everything in just one hour, but thankfully, the interviewer was more interested in the implementation than the time constraint

Round 7: Hiring manager round

Very chill round compared to the others.

• Mostly about past projects, team dynamics, and growth plans.
• The manager was super friendly and kept things conversational

Qualifier Coding Round

This round focused on designing a data structure with O(1) time complexity for retrieves, updates, deletes, and retrieving keys with maximum and minimum frequency.

Coding Round 1

I tackled a variant of the Rat in a Maze problem, emphasizing pure OOP principles like readability, maintainability, testability, and time complexity. I felt it went well, though I initially missed one edge case, which I later corrected.

Design Round

The problem involved designing a system to fetch top articles shared by users within various time windows (15 min, 60 min, 24 hours). The interviewer later extended this to more granular and dynamic time intervals. I discussed solutions leveraging Apache Flink for stream processing, including handling windowing, aggregation, fault tolerance, and out-of-order events. Despite my efforts, the feedback indicated my dynamic window solution wasn't accurate enough.

Craftsmanship Round

This round was a discussion about project metrics, CI/CD processes, Reactive Systems, and other technical topics. I believe I performed well here.

Leadership Round

The focus was on leadership and in-depth discussions of projects I had led. I felt confident in my performance in this round.

Coding Round 2

In the second coding round, I was given two problems. The first was to check if a number is a power of 2. The second, more challenging, was to find the node least number of edges away from any other node in a binary tree. For the second problem, my initial DFS-based solution wasn't what the interviewer expected; they preferred BFS. I fumbled a bit trying to explain my approach, as they seemed to be looking for a more perfect and optimized solution.

Ultimately, I was rejected. My struggles in the coding rounds, particularly with the specific algorithmic approaches and explanations, were highlighted as the primary reason, reinforcing the expectation for flawless solutions.

I interviewed for a Senior Data Engineer (IC3) position at LinkedIn. The process started with an Online Assessment on Hackerrank, which lasted 2 hours. I had to solve two Leetcode Medium DSA questions and two SQL medium questions. I successfully completed all four problems within the given time, passing all test cases.

Following the OA, I had a 1-hour Telephonic Screening. Two interviewers from the hiring team joined, and the emphasis was on optimizing code and queries. I was given one Leetcode Medium DSA question with follow-ups and one SQL Medium question focusing on window/rank functions, also with follow-ups. I felt this round went well and was confident about receiving an on-site invitation.

After receiving positive feedback from Round 0, HR scheduled my on-site interviews for a single day. Each interview round lasted one hour.

Round 1: DSA

In this round, I tackled a Leetcode medium question related to "top k elements," and I made sure to present an optimal approach. Additionally, I was presented with a scenario-based question where my choice of data structure and the complexities of various use-cases within that scenario were evaluated. I felt good about this round, rating it around 7/10.

Round 2: Data Manipulation

This round involved two scenarios with different dataset schemas. I faced multiple questions for each scenario, primarily dealing with timestamps and ranks. My task was to solve each use case using optimized SQL Queries or pyspark. I thought this round also went well, rating it 8/10.

Round 3: System Design / Data Architecture

Here, I engaged in an end-to-end data system design discussion, covering various use cases. The main focus was on ETL pipelines and data storage. We delved into how data would be stored and optimized for querying, discussing the scenario, multiple corner cases, and how to address them in the data architecture. I felt this was another solid round, rating it 7/10.

Round 4: Technical Discussion

This round involved discussing my technical projects. I shared challenges I faced while working on my current project and explained how I resolved them. We also covered multiple behavioral/technical questions related to project planning and feature designing/implementation. I felt this round went very well, rating it 8/10.

Round 5: Hiring Manager

The final round was with the Hiring Manager. This round primarily consisted of behavioral questions, discussions about my projects and skills, and back-and-forth communication regarding how things operate at LinkedIn. I was also asked about my motivations for choosing LinkedIn and my aspirations. Hiring Manager rounds are always crucial and can be tricky, so I'm never overly confident about them. I rated this round 7/10.

Overall, I'd rate my entire interview experience around 7.5/10. I might be under-estimating my performance, possibly due to hints I received from the interviewers. I'm currently waiting for the final decision.

I recently participated in a phone screen interview with Linkedin for the Senior Software Engineer, Systems Infrastructure role in Sunnyvale. The interviewer started by asking me to walk through one of my chosen projects and discuss what I might have done differently in retrospect. Following that, we delved into a series of conceptual questions focused on operating systems, including the distinctions between processes and threads, mutexes versus semaphores, and an in-depth discussion on deadlocks, paging, and page faults.

The interview also covered specific Python language intricacies, such as the difference between the 'is' and '==' operators, and when to use 'copy' versus 'deepcopy'. Finally, I was given a LeetCode problem, Nested List Weight Sum II, which required an algorithmic solution.

Hey everyone, hope you're doing well! I currently work as an SDE-2 at Amazon and recently had the opportunity to interview with LinkedIn for an SDE-3 backend role. The recruiter reached out to me by email, and we had an initial call discussing my current roles and responsibilities, as well as the details of the position they were hiring for. They were particularly interested in whether I had dealt with concurrency issues in the past, so it's good to be prepared with specific instances.

Round 1

I was reached out by a recruiter on LinkedIn for an SDE role. I have 2.5 years of experience and currently work as a Software Engineer at a FAANG-level company, having completed my B.Tech from an NIT.

Phone Screen Round

The interview started with a discussion about my current project, followed by technical questions on Operating Systems, Java, JVM internals, and SQL. After about 15 minutes, the interviewer presented a medium-hard graph problem: finding a path for a knight on an infinite 2D grid from a start to an end point. I explained both DFS and BFS approaches, detailing why BFS would be more suitable here, and then implemented my solution. The interviewer seemed satisfied. Two days later, I was informed that I had cleared this round and would proceed to four more.

Round 1: DSA Round

This round was heavily focused on Data Structures and Algorithms. The first problem was a hard-level n-ary tree problem that required representing it as a graph to explore combinations for an optimal solution. I explained my approach and coded it, but couldn't find a way to further optimize the time complexity beyond evaluating all combinations, despite the interviewer's suggestion. The second problem involved powers and mathematical interpretation. I shared my approach, implemented the code, and solved it successfully.

Round 2: DSA Round

After introductions, we immediately delved into two DSA problems within an hour. The first was a tree problem requiring level order traversal and indegree calculations. I proposed multiple approaches, including reversing the level order traversal, before explaining the optimal one and implementing it. This took around 40 minutes. The second problem was a classic 1D DP problem using the pick-and-not-pick strategy. I quickly explained how to achieve O(1) space complexity and coded it, finishing just as the time ran out.

Round 3: High-Level System Design

Two interviewers conducted this round, asking me to design a job scheduling system. The core discussion revolved around scaling the solution, identifying bottlenecks, and addressing security concerns. It was a very interactive session with numerous follow-up questions on components like load balancers and API gateways.

Round 4: Hiring Manager Round

This 30-40 minute round involved general discussions about my typical day at work, the tech stack I've used, and my motivations for seeking a change from my current company.

Outcome and Reflection

Two days later, the recruiter informed me that the feedback was not positive. I tried to get more details on my performance but did not receive a response. Based on my assessment, I believe the System Design round might have been the reason for my rejection. While the experience was valuable, I felt the expectations in some rounds, like solving one hard and one medium-hard problem within an hour, were unrealistic. It felt like interviewers lacked empathy for time constraints. Nevertheless, it was a good learning opportunity to identify areas where I need to improve my efficiency and competence.

After facing constant rejections from March this year from companies like Amazon, Google, Microsoft, Uber, Meta, Stripe, and Atlassian, I had zero expectations for the LinkedIn interview. I realized I wasn't handling rejections well and decided to take a month-long vacation to reset. I returned with a fresh perspective, deciding to just put in the effort without worrying about the outcome. Luck certainly played a role in me getting this offer before the year ended. I approached the LinkedIn interviews with a very relaxed mindset.

Here’s how my interview process unfolded:

Round 1 - Technical Phone Screen

This round involved two coding questions. The first was the classic Maximum Subarray Sum (Kadane’s Algorithm), with no modifications. The second was a tree-based data structure question, but unfortunately, I don't recall the exact problem. I received a strong hire verdict for this round.

Onsites - Round 1 DSA

I was given two questions in this round. One was very similar to K Closest Points to Origin on LeetCode. The second was a hard array question that I also can't recall. I managed to solve the first, but for the second, I could only discuss my approach as I ran out of time.

Onsites - Round 2 DSA

This was the most challenging round for me, featuring two hard questions. The interviewer was very kind and extended the time by 15 minutes. The first question was exactly Sliding Window Maximum, which I was somehow able to implement. The second question was quite challenging: finding the top k elements after multiplying values from two arrays (e.g., arr1 = [1, 2, 5, 9], arr2 = [1, 3, 4, 6]). The interviewer explicitly stated that the brute-force approach of multiplying all pairs was not expected. I could only discuss my approach before time ran out.

Onsites - Round 3 Host Leader

This was a typical hiring manager round, focusing on my experience and motivations. It went quite well.

Onsites - Round 4 Technical Communication

In this round, I was asked to explain the most challenging project I had worked on. I articulated the complexities and my solutions effectively, and this round also went very smoothly.

Onsites - Round 5 System Design

The system design problem was to design a Top K system to gather exceptions from different services and display the top K exceptions within a 24-hour window. I discussed various architectural approaches and data pipelines, and I felt this round went pretty well too.

I was ultimately selected and will update compensation details soon. I hope my experience helps others facing rejections; persistence is truly underrated, and sometimes, a bit of luck plays its part.

My interview journey at LinkedIn for the SSE position in India involved several distinct rounds.

The Tech Screening started with theoretical questions about operating system concepts like processes vs. threads and virtual memory. Following this, I was asked to design a data structure capable of adding an element and removing a random element, both in O(1) time. I explained a solution involving an ArrayList where a random element is swapped with the last element before removal.

Coding Module 1 presented two problems. The first involved connected components of a graph, which I was able to solve. The second was the well-known Celebrity Problem. I could only come up with an O(n^2) brute-force solution, and an optimal solution was expected.

Coding Module 2 also had two problems. The first was to find the k closest elements to a target in a Binary Search Tree (BST) within O(n) time and O(k) space. I struggled with this, contemplating an in-order traversal with a k-size Deque but couldn't finalize it. The second problem was to design a data structure that supports incrementing/decrementing keys and retrieving keys with max/min frequency in O(1) time. I approached this using concepts similar to the LRU cache problem, and believe I provided a valid solution.

The Complex System Design round focused on designing a Metric Collection System, specifically emphasizing the data store component.

Finally, the Host Manager round was a general discussion about my past projects, diving deep into a recent one, my role, impact, and the challenges I faced.

My interview process began with a phone screen. The technical part involved a problem called RetainBestCache, where I was asked to make it thread-safe and identify potential race conditions for each locked section. Additionally, we discussed fundamental operating system concepts such as the differences between processes and threads, the roles of heap and stack memory, and methods for inter-process communication.

The first on-site round was dedicated to coding and algorithms. I was presented with two problems: Closest Binary Search Tree Value II and Paint House.

The second on-site round was with a hiring manager. This round focused on behavioral questions and an in-depth discussion about my past projects and experiences.

The third on-site was another coding round. Here, I had to solve Number of Islands and Binary Tree Upside Down.

Finally, the fourth on-site was a system design round. We started with approximately 10 minutes discussing my previous projects. Following that, the core problem involved designing a high-level system for scheduling cron jobs with fixed intervals.

My interview process at LinkedIn started with a telephone screen. After a brief introduction, I was asked to draw a High-Level Design (HLD) of the services I was currently working on. We delved into details such as TPS in each service, queuing write semantics, DB consistency levels, authorization and authentication mechanisms (whether home-grown or LDAP), and challenges I faced in my projects. Following this, I was tasked with designing a thread-safe HashMap from scratch.

Round 1 focused on algorithms. I was given a list of strings denoting function names, 'START' or 'END' markers, and timestamps. The problem required me to calculate the inclusive and exclusive time for any given function call, considering nested calls. The second question in this round involved checking if a given list of undirected edges formed a valid tree among 'n' nodes.

Round 2 presented two more algorithmic challenges. The first was to order tree nodes based on a 'falling' sequence, where child nodes fall first, followed by their parents whose children have already fallen. The second, and ultimately my downfall, was to find all palindromic subsequences in a string.

Round 3 was a system design interview. The scenario involved a large deployment with hundreds of machines, each exposing thousands of statistics as [source, metric-name, value] tuples. I needed to design a scalable system to collect and aggregate these tuples, with consumers like engineers needing to see application latency over a month, an alert service, and the ability to query metrics for specific sources within a time range.

Finally, Round 4 was a concurrency-focused round. After some basic questions, I was asked to design a blocking queue that would be written to by 'n' writers and read by '1' reader. This problem was then extended to support 'n' readers and 'n' writers.

Despite my efforts, I was rejected because I couldn't solve the 'find all palindromic subsequences' problem.

I recently completed my job hunt and wanted to contribute back by sharing my interview experience at LinkedIn. I interviewed for a Software Engineer role in Bangalore, with approximately 3.9 years of experience.

Online Assessment: 90 minutes, 4 questions

This round consisted of four questions. I encountered problems like Paint House and Minimum One Bit Operations to Make Integers Zero. Additionally, there was an easy question about finding the max of power and another to find the length of the longest substring with at most K normal characters.

Onsite Interviews: 5 rounds on a single day

All onsite rounds had two interviewers.

Round 1: Coding

I was asked to solve problems such as Find the Celebrity and Binary Tree Upside Down.

Round 2: Host Manager

This round involved a briefing about the team I might be joining, followed by questions about my past work, current role, and responsibilities at my previous company.

Round 3: Coding

In this coding round, I tackled Find K Closest Elements and a problem involving transforming word1 to word2 using a dictionary, with only one letter change allowed per transition.

Round 4: Technical Communication

This round primarily focused on a detailed discussion around my current projects.

Round 5: System Design

I was challenged with designing a stats collector capable of showing the top 200 queries executed in the last 24 hours, keeping in mind a very large traffic volume.

Unfortunately, I could not perform well in the system design round, which ultimately led to my rejection.

I had an onsite interview at Linkedin for a Senior Software Engineer (AI/ML) position. The interview process consisted of several rounds:

ML Round 1: This was an open-ended problem focused on a specific Linkedin product. I found it challenging to grasp the problem initially, which consumed a significant amount of my time. We then delved into various use-cases and strategies for data collection and preparation, concluding with a discussion on model deployment and feedback loops.

ML Round 2: This round involved both coding and discussion. One problem was a modification of a binary search problem, which I hadn't encountered on Linkedin before. There was also a problem related to large-scale random sampling, described as a modification of Random Pick with Weight, which I struggled with.

ML Round 3: This round required me to derive a modified popular ML theorem. I had difficulty understanding the problem statement, and the derivation itself took a considerable amount of time. We also discussed real-world examples and potential issues a data scientist might face, which was outside my expertise and took me a long time to fully comprehend.

ML Round 4: This was with an engineering manager. The discussion centered around my past projects, experiences, challenges faced, and how I resolved conflicts. We also tackled an open-ended problem related to the manager's team, discussing trade-offs and other relevant aspects.

Coding Round 5: This round was quite straightforward. I was asked to:

• Detect cycle in an undirected graph
• Detect cycle in a directed graph
• Solve a problem related to Permutation in String