What does Snap ask in software engineer interviews?

Snap SWE interviews typically cover data structures and algorithms, system design, and behavioral questions. Candidates report coding rounds using LeetCode-style problems, plus architecture design and leadership questions for senior roles. LeakCode aggregates verified reports from 188+ candidates.

How many rounds does Snap have in its interview process?

The Snap interview process typically includes a recruiter screen, a phone/online assessment round, and 4-5 onsite or virtual interviews covering coding, system design, and behavioral competencies. The exact number of rounds varies by role and team.

How hard is it to get a job at Snap?

Snap is highly selective. Candidates report pass rates in the single digits for competitive engineering roles. Strong data structures fundamentals, system design ability, and clear communication are required to advance past initial screens.

What topics should I study for a Snap interview?

Based on aggregated Snap interview reports: arrays and hash maps, trees and graphs, dynamic programming, system design (distributed systems, databases, caching), and behavioral questions using the STAR method. LeakCode shows exactly which topics appear most often.

Does Snap ask LeetCode hard questions?

Interview difficulty at Snap varies. Coding rounds typically include medium to hard difficulty algorithmic problems. System design questions are open-ended and evaluated on depth of reasoning. Browse real Snap interview questions on LeakCode to see the actual difficulty distribution.

Snap Interview Questions (2026)

47 questions · 43 experiences · 1p3a_oj (54) · LeetCode (32) · 1p3a (3) · Reddit (1)

By year: 2026 2025 2024 2023

Read our Snap interview guide

Browse by role

Software Engineer 86

Snap Inc. Technical Interview: BFS Grid Traversal for Nearest k Restaurants

SWE Technical

Question Details

The interview started with around 10–15 minutes of background discussion, where the interviewer asked about my experience — especially around backend systems and ML-related work. After that, we moved into a live coding round on HackerRank. The problem was a grid-based traversal question focused on finding the nearest k entities using shortest path logic.

Problem Statement: You are given a 2D grid representing a map. Each cell in the grid contains one of the following: - ' ' (space) → an empty cell that can be traversed - '-' → a wall that cannot be traversed - 'A' to 'Z' → a restaurant You are also given: a starting position (row, col) an integer k

Task:

Return the top k nearest restaurants from the starting position based on the minimum number of steps required to reach them.

Movement Rules You can move in 4 directions: - up → (r - 1, c) - down → (r + 1, c) - left → (r, c - 1) - right → (r, c + 1)

Output:

Return a dictionary/map: - At most k restaurants - If fewer than k are reachable →

return all reachable ones

Constraints Grid size: m x n 1 ≤ m, n k ≥ 1 Starting position is within bounds Restaurants are labeled 'A'–'Z' from collections import deque from typing import List, Dict def nearest_restaurants(grid: List[List[str]], start_row: int, start_col: int, k: int) -> Dict[str, int]:

Edge case: empty grid or invalid k if not grid or not grid[0] or k <= 0:

return {} rows, cols = len(grid), len(grid[0])

Edge case: invalid starting position if not (0 <= start_row < rows and 0 <= start_col < cols):

return {}

Edge case: starting cell is a wall → cannot move if grid[start_row][start_col] == '-':

return {} # Helper to check if a cell is a restaurant def is_restaurant(ch: str) -> bool:

return len(ch) == 1 and 'A' <= ch <= 'Z' # BFS initialization queue = deque([(start_row, start_col, 0)]) # (row, col, distance) visited = {(start_row, start_col)} result = {} # 4-directional movement directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] # BFS traversal while queue: r, c, dist = queue.popleft() # If current cell is a restaurant → record it if is_restaurant(grid[r][c]): label = grid[r][c] # Avoid duplicate entries if label not in

result result[label] = dist # Early stop: we found k nearest restaurants if len(result) == k:

return result # Explore neighbors for dr, dc in directions: nr, nc = r + dr, c + dc # Valid move conditions: # 1. Inside grid bounds # 2. Not visited # 3. Not a wall if ( 0 <= nr < rows and 0 <= nc < cols and (nr, nc) not in visited and grid[nr][nc] != '-' ): visited.add((nr, nc)) queue.append((nr, nc, dist + 1))

Return whatever restaurants we found (if < k)

return result

Time Complexity Time: O(m × n) Space: O(m × n) Each cell is visited at most once.

Why BFS ? Because: - All moves have equal cost - BFS guarantees shortest path - First visit = minimum distance

Free preview — 6 questions shown. Unlock all Snap questions →

Topics

Hash Table Graph Matrix Queue Heap Ml Stack

View full page →

Related companies

Uber 1341 LinkedIn 1244 ByteDance 605 OpenAI 512 Stripe 453 DoorDash 426 Anthropic 283 Databricks 256 Airbnb 215 Twitter/X 188

Snap Interview Process Overview

The Snap interview process typically includes a recruiter screen, one to two technical phone screens, and a 4-6 round on-site or virtual on-site loop. Each round serves a distinct calibration purpose: coding rounds measure correctness, code quality, and complexity reasoning; system design rounds measure architectural judgment at the appropriate level; behavioral rounds measure ownership, leadership scope, and collaboration. Reports tagged on LeakCode from 2024-2026 show Snap runs a calibrated process consistent with industry norms for companies of its tier.

Difficulty calibration: Snap coding rounds typically run medium difficulty with follow-up depth as the senior discriminator. System design rounds expect production-grade trade-off articulation at L4+ levels. Behavioral rounds expect quantified outcomes ("reduced p99 latency from 800ms to 120ms") rather than vague impact claims. The candidates who advance consistently demonstrate clear thinking out loud rather than perfect final answers.

How To Use Snap Question Reports

Real candidate-reported interview questions are a calibration tool, not a memorization target. Snap updates its question pool every 2-4 months; memorizing exact problems risks misleading you when the interviewer uses a variant. The high-leverage approach: identify the patterns that appear repeatedly in Snap reports, practice those patterns on similar (not identical) problems, and use the reports to understand the interviewer's typical follow-up depth.

Filter the questions above by round type, difficulty, and recency. Focus first on reports from the past 6-12 months; older reports may reference questions that have since rotated out of Snap's pool. Reports tagged with quantified difficulty and explicit round type are higher-signal than reports without those tags. The metadata filters help you build a focused study plan in 1-2 hours rather than 8-10 hours of unstructured browsing.

Common Snap Interview Mistakes

Reports tagged "no hire" at Snap consistently surface a few patterns: jumping into code without clarifying requirements, coding silently for extended periods, missing edge cases (empty input, single element, large input, overflow), producing working code the candidate cannot refactor when probed, and behavioral stories that use "we" instead of "I" diluting individual signal. Strong candidates explicitly avoid these patterns by following a consistent round template.

The single most predictive failure mode in recent reports: not asking clarifying questions. Interviewers are explicitly trained to weight this dimension. Strong candidates ask 3-5 clarifying questions even on problems that look obvious; weak candidates dive into implementation immediately. Strong candidates also verbalize their approach before writing code; weak candidates code in silence and lose the communication dimension of the round's calibration.