LinkedIn Interview Guide 2026: Social Graph Engineering, Feed Ranking, and Professional Network Scale

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 Company Interview Guides

Explore all our company interview guides covering FAANG, startups, and high-growth tech companies.