LinkedIn Interview Guide 2026: Social Graph Engineering, Data Systems, and Professional Network Scale
LinkedIn operates the world’s largest professional network with 1B+ members. Their engineering challenges center on social graph queries at scale, feed ranking, job matching ML, and real-time notifications. This guide covers SWE interviews from Staff E4 through Staff E6.
The LinkedIn Interview Process
- Recruiter screen (30 min)
- Technical phone screen (1 hour) — 1–2 coding problems
- Onsite (4–5 rounds):
- 2× coding (LeetCode-style, medium-hard)
- 1× system design (feed, search, messaging, or graph)
- 1× hiring manager / values alignment
- 1× (for senior) cross-functional leadership discussion
LinkedIn acquired by Microsoft in 2016; culture blends LinkedIn’s original startup DNA with Microsoft’s enterprise rigor. Expect questions about impact measurement and data-driven decisions.
Core Algorithms: Graph Problems
LinkedIn’s core data structure is the social graph. Expect graph traversal, shortest paths, and degree-of-separation queries.
Second-Degree Connection Discovery
from collections import defaultdict, deque
from typing import Set, Dict, List
class ProfessionalGraph:
"""
Social graph operations used in LinkedIn's "People You May Know" feature.
LinkedIn's actual graph has 1B+ nodes; uses distributed graph databases
(Voldemort, Espresso) with sharding by member ID.
"""
def __init__(self):
self.adjacency = defaultdict(set) # member_id -> set of connection_ids
def add_connection(self, a: int, b: int):
self.adjacency[a].add(b)
self.adjacency[b].add(a)
def get_connections(self, member_id: int, degree: int) -> Dict[int, int]:
"""
BFS to find all connections within `degree` hops.
Returns {member_id: distance} dict.
Time: O(V + E) in the local neighborhood
Space: O(V) visited set
"""
visited = {member_id: 0}
queue = deque([member_id])
while queue:
current = queue.popleft()
current_dist = visited[current]
if current_dist >= degree:
continue
for neighbor in self.adjacency[current]:
if neighbor not in visited:
visited[neighbor] = current_dist + 1
queue.append(neighbor)
visited.pop(member_id) # exclude self
return visited
def people_you_may_know(
self,
member_id: int,
limit: int = 20
) -> List[tuple]:
"""
Suggest connections based on mutual connections count.
Algorithm:
1. Get all 2nd-degree connections (friends-of-friends not yet connected)
2. Score by mutual connection count
3. Return top-K by score
Time: O(D1 * D2) where D1, D2 are avg degrees of 1st/2nd degree nodes
"""
direct = self.adjacency[member_id]
mutual_counts = defaultdict(int)
for friend in direct:
for friend_of_friend in self.adjacency[friend]:
if friend_of_friend != member_id and friend_of_friend not in direct:
mutual_counts[friend_of_friend] += 1
suggestions = [(count, person)
for person, count in mutual_counts.items()]
suggestions.sort(reverse=True)
return [(person, count) for count, person in suggestions[:limit]]
def shortest_path(self, source: int, target: int) -> List[int]:
"""
BFS shortest path between two members.
LinkedIn's "How You're Connected" feature.
Time: O(V + E)
Space: O(V)
"""
if source == target:
return [source]
parent = {source: None}
queue = deque([source])
while queue:
current = queue.popleft()
for neighbor in self.adjacency[current]:
if neighbor not in parent:
parent[neighbor] = current
if neighbor == target:
# Reconstruct path
path = []
node = target
while node is not None:
path.append(node)
node = parent[node]
return path[::-1]
queue.append(neighbor)
return [] # no path
Job Recommendation with Skill Matching
class JobMatcher:
"""
Simplified job recommendation using TF-IDF skill matching.
LinkedIn's actual system uses Graph Neural Networks and
feature-rich ML models with 100s of signals.
Key signals: skill overlap, title match, location, seniority,
company size preference, salary range, commute distance.
"""
def __init__(self):
self.jobs = {} # job_id -> {required_skills, title, level, salary}
def add_job(self, job_id: int, required_skills: List[str],
title: str, level: str, min_salary: int):
self.jobs[job_id] = {
'skills': set(s.lower() for s in required_skills),
'title': title.lower(),
'level': level,
'min_salary': min_salary,
}
def score_match(
self,
member_skills: List[str],
desired_salary: int,
desired_level: str,
job_id: int
) -> float:
"""
Score how well a job matches a member's profile.
Returns score in [0, 1].
"""
job = self.jobs[job_id]
member_skill_set = set(s.lower() for s in member_skills)
# Skill overlap (Jaccard similarity)
intersection = member_skill_set & job['skills']
union = member_skill_set | job['skills']
skill_score = len(intersection) / len(union) if union else 0
# Level match
level_score = 1.0 if job['level'] == desired_level else 0.5
# Salary fit
if job['min_salary'] <= desired_salary * 1.1:
salary_score = 1.0
elif job['min_salary'] List[tuple]:
scores = [
(self.score_match(member_skills, desired_salary, desired_level, jid), jid)
for jid in self.jobs
]
scores.sort(reverse=True)
return [(jid, score) for score, jid in scores[:limit]]
System Design: LinkedIn Feed
Common question: “Design LinkedIn’s news feed.”
Fan-Out Strategies
"""
LinkedIn Feed Architecture:
Two approaches to fan-out:
1. Fan-out on Write (Push model):
- When Alice posts, immediately write to all her followers' feeds
- Pro: Fast reads (pre-computed)
- Con: Expensive for members with 10K+ connections (celebrities)
2. Fan-out on Read (Pull model):
- When Bob opens feed, pull recent posts from all connections
- Pro: No wasted write work for inactive users
- Con: Slow read, O(connections * posts_per_person)
LinkedIn uses HYBRID:
- Regular users ( float:
"""
Multi-factor post scoring for feed ranking.
post: {engagement_rate, author_connection_degree,
topics, posted_at, sponsored}
"""
import math
# 1. Recency score (exponential decay)
hours_old = (current_time - post['posted_at']) / 3600
recency = math.exp(-hours_old / self.recency_half_life_hours)
# 2. Engagement score (predicted based on similar posts)
engagement = post.get('predicted_engagement_rate', 0.05)
# 3. Social proximity (1st degree > 2nd degree > 3rd degree)
proximity_weights = {1: 1.0, 2: 0.6, 3: 0.3, 0: 0.2}
proximity = proximity_weights.get(post.get('author_connection_degree', 0), 0.1)
# 4. Topic relevance
viewer_topics = set(viewer_profile.get('interests', []))
post_topics = set(post.get('topics', []))
topic_overlap = len(viewer_topics & post_topics) / max(len(viewer_topics | post_topics), 1)
# 5. Sponsored content gets score cap
if post.get('sponsored'):
return min(0.3, 0.15 * recency + 0.1 * engagement)
return (0.35 * recency + 0.30 * engagement +
0.20 * proximity + 0.15 * topic_overlap)
LinkedIn-Specific Technical Topics
- Voldemort: LinkedIn’s distributed key-value store (open source); used for member profiles, connections
- Kafka: Open-sourced by LinkedIn; used for activity streams, notifications, audit logs
- Espresso: Document store for mutable data with ACID transactions
- Pinot: Real-time analytics at LinkedIn (who viewed your profile counts)
- Venice: Derived data store fed by Kafka for fast read serving
Behavioral Questions at LinkedIn
- “How have you created economic opportunity for others?” — LinkedIn’s mission; connect your work to job market impact
- Ownership and initiative: Examples of driving projects without being asked
- Data-driven decision making: How you’ve used metrics to guide engineering decisions
- Collaboration across orgs: LinkedIn has many teams; cross-functional work matters
Compensation (E4–E6, US, 2025 data)
| Level | Title | Base | Total Comp |
|---|---|---|---|
| E4 | SWE | $180–210K | $250–330K |
| E5 | Senior SWE | $210–250K | $340–450K |
| E6 | Staff SWE | $250–300K | $460–620K |
LinkedIn (Microsoft subsidiary) RSUs are in Microsoft stock, which provides stability. Vest quarterly over 4 years.
Interview Tips
- Use LinkedIn: Understand the feed, search, InMail, job recommendations as a power user
- Graph algorithms: BFS/DFS, Dijkstra, topological sort — all relevant to social graph problems
- Read LinkedIn Engineering Blog: engineering.linkedin.com has deep posts on their systems
- Know Kafka deeply: LinkedIn invented it; knowing producer/consumer groups, partition design is a plus
- SQL and analytics: LinkedIn uses heavy analytics; complex window functions, CTEs are fair game
Practice problems: LeetCode 133 (Clone Graph), 684 (Redundant Connection), 1334 (Find the City), 547 (Number of Provinces).
Related System Design Interview Questions
Practice these system design problems that appear in LinkedIn interviews:
- Design a News Feed (Facebook-style)
- Design a Recommendation Engine (Netflix-style)
- System Design: Notification System (Push, Email, SMS)
- System Design: Search Autocomplete (Google Typeahead)
Related Company Interview Guides
- Airbnb Interview Guide 2026: Search Systems, Trust and Safety, and Full-Stack Engineering
- Vercel Interview Guide 2026: Edge Computing, Next.js Infrastructure, and Frontend Performance
- Netflix Interview Guide 2026: Streaming Architecture, Recommendation Systems, and Engineering Excellence
- Coinbase Interview Guide
- Figma Interview Guide 2026: Collaborative Editing, Graphics, and Real-Time Systems
- Meta Interview Guide 2026: Facebook, Instagram, WhatsApp Engineering
- System Design: Apache Kafka Architecture
- System Design: Distributed Cache (Redis vs Memcached)
- System Design: Rate Limiter
- Machine Learning System Design: Ranking and Recommendations
- System Design: Social Network at Scale
- System Design: Search Autocomplete / Typeahead
- System Design: Web Crawler (Google Search Indexing)
- System Design: Data Pipeline and ETL System (Airflow / Spark)
- System Design: Distributed Task Queue (Celery / SQS / Sidekiq)
- System Design: Code Repository and CI/CD (GitHub / GitLab)
- System Design: Fraud Detection System
- System Design: Ride-Sharing App (Uber / Lyft)
- System Design: Video Conferencing (Zoom / Google Meet)
- System Design: Real-Time Bidding Platform
- System Design: Database Replication and High Availability
- System Design: Machine Learning Training Infrastructure
- System Design: Serverless Architecture and FaaS
- System Design: Zero-Downtime Deployments
- System Design: Data Warehouse and OLAP Architecture
- System Design: Service Mesh and Microservice Communication
- System Design: Log Aggregation and Observability Pipeline
- System Design: Search Engine and Elasticsearch Internals
- System Design: Social Graph and Friend Recommendations
- System Design: Content Moderation at Scale
Explore all our company interview guides covering FAANG, startups, and high-growth tech companies.