Google SWE Intern & University Hire (L3) — Hiring Process, Syllabus & Prep Roadmap
Preparing for Google requires high-bar DSA and problem-solving skills. The process for Interns and L3 University Hires involves rigorous coding interviews, algorithmic depth, and for L3, lightweight system design and the famous 'Googliness' behavioural evaluation. Use the patterns and roadmap below to structure your prep.
Intern: 2 coding rounds (45–60 min). L3: 1 phone screen + 4–5 on-site rounds (2–3 coding, 1 system design, 1 behavioural).
Last updated:
Exam Pattern
Intern: 2 coding rounds (45–60 min). L3: 1 phone screen + 4–5 on-site rounds (2–3 coding, 1 system design, 1 behavioural).
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| SWE Intern · Technical Interviews | 2 rounds | 45–60 min each | DSA / Algorithms | Medium |
| L3 · Technical Phone Screen | 1 round | 45 min | DSA / Problem Solving | Medium |
| L3 · On-site Coding | 2–3 rounds | 45–60 min each | DSA / Follow-ups | Medium–Hard |
| L3 · System Design | 1 round | 45–60 min | Lightweight Architecture | Medium |
| L3 · Googliness & Leadership | 1 round | 45 min | Behavioural (STAR) | Medium |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. Coding Mastery (DSA)
Arrays & Strings
- • Prefix sums
- • Two pointers
- • Sliding window
- • Hashing
- • Subarrays & subsequences
- • Palindromes
- • Anagrams
- • String matching
- • Coordinate compression
- • In-place manipulation
Linked Lists, Stacks & Queues
- • Reverse linked list
- • Reverse in groups of k
- • Detect cycle & entry point
- • Merge k sorted lists
- • Clone random-pointer list
- • Balanced parentheses
- • Min stack
- • Next greater element
- • Largest rectangle in histogram
- • Sliding-window maximum
Trees & BSTs
- • Recursive & iterative traversals
- • Level-order traversal
- • Height & diameter
- • Lowest common ancestor
- • Validate BST
- • Serialize & deserialize
- • Build tree from traversals
- • Maximum path sum
- • Tree views
- • Binary lifting basics
Graphs
- • BFS & DFS
- • Connected components
- • Cycle detection
- • Bipartite graph
- • Topological sorting
- • Course scheduling
- • Dijkstra & Bellman-Ford
- • Minimum spanning tree
- • DSU
- • Strongly connected components
- • Bridges & articulation points
- • Multi-source BFS
Dynamic Programming
- • 1D & Grid DP
- • House robber
- • Coin change
- • 0/1 knapsack
- • LIS & LCS
- • Edit distance
- • Word break
- • Stock buy-sell
- • Partition & Interval DP
- • Tree DP
- • Bitmask & Digit DP
Advanced Data Structures
- • Heaps (Top K elements)
- • Median from data stream
- • Trie (Autocomplete)
- • Segment tree
- • Fenwick tree
- • LRU cache
- • Union-find
2. L3 System Design & CS Core
System Design Basics
- • URL shortener
- • Rate limiter
- • Notification service
- • Distributed cache
- • File storage
- • Search autocomplete
- • Chat system
- • News feed
- • API gateway
- • Scalability & Load balancing
- • Replication & Partitioning
Operating Systems
- • Process vs Thread
- • Context switching
- • Scheduling algorithms
- • Mutex & Semaphore
- • Deadlock
- • Paging & Virtual memory
- • Race conditions
DBMS
- • Keys & Normalisation
- • Joins
- • Indexing
- • Transactions & ACID
- • Isolation levels
- • Serialisability
- • Query optimisation
Networking
- • TCP vs UDP
- • HTTP/HTTPS
- • DNS
- • TLS
- • Load balancing
- • Caching
- • REST vs RPC
- • Rate limiting
- • Retries & timeouts
Most Asked Topics
Highest-frequency areas across recent test papers.
Sliding Window
Longest substring condition and minimum window problems are high-frequency patterns.
Graph BFS/DFS
Shortest unweighted path, cycle detection, and grid-based connectivity problems.
Heaps / Priority Queue
Top K items and maintaining a median from a data stream using two heaps.
Tries
Essential for prefix matching, word search, and autocomplete system design.
Segment/Fenwick Trees
Common in hard follow-ups for range query and point update scenarios.
Googliness (STAR)
Behavioural evaluation focusing on leadership, ambiguity, and team collaboration.
Free Resources
Curated practice links per section.
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & Strings
- Longest substring without repeating characters
- Minimum window substring
- Product of array except self
- Smallest missing positive integer
- Merge intervals
- Trapping rainwater
- Longest consecutive sequence
Trees & Graphs
- Lowest common ancestor
- Serialize & deserialize binary tree
- Maximum path sum
- Number of islands
- Course schedule
- Word ladder
- Clone graph
- Shortest path in weighted graph
DP & Heaps
- Edit distance
- Word break
- Median from data stream
- Top K frequent elements
- Merge K sorted lists
- House robber
- Stock buy-sell
Backtracking
- N-Queens
- Word search
- Generate parentheses
- Palindrome partitioning
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
Coding (Google-style)
- Find the smallest missing positive integer in O(n) time and O(1) space.
- Find the minimum window in a string containing all characters of another string.
- Find the median from a stream of numbers using two heaps.
- Implement an autocomplete system using a Trie and a ranking structure.
- Determine whether a directed graph contains a cycle using DFS colouring.
- Clone a graph using BFS/DFS with an old-to-new node map.
System Design (L3)
- Design a rate limiter (Token bucket or Leaky bucket approach).
- Design a distributed lock (Consider ownership, expiry, and idempotency).
- Design a URL shortener with high availability.
- Design a notification service supporting multiple channels.
- How would you scale a search autocomplete system for 100k queries per second?
Googliness / Behavioural
- Tell me about a difficult technical problem you solved.
- Tell me about a time you disagreed with a teammate's approach.
- Describe a failure and what you learned from it.
- Tell me about a time you took initiative to improve a process.
- Why Google? Why this specific technical area?
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Data Analysis
Second highest salary
SELECT MAX(salary) FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);Department-wise average salary
SELECT dept_id, AVG(salary)
FROM employees
GROUP BY dept_id
HAVING AVG(salary) > 50000;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What is the difference between a Clustered and Non-Clustered index?
A clustered index defines the physical order of data in the table, while a non-clustered index is a separate structure that points to the data.
What are ACID properties?
Atomicity, Consistency, Isolation, and Durability - the fundamental properties for reliable database transactions.
What is Database Normalisation?
The process of organising data to reduce redundancy and improve data integrity (1NF, 2NF, 3NF, BCNF).
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
Polymorphism
Ability of an object or function to take on multiple forms, e.g., method overloading (compile-time) and overriding (run-time).
Encapsulation
Restricting direct access to data members and using getter/setter methods to maintain state integrity.
Interface vs Abstract Class
Interfaces define a contract (what to do), while abstract classes can provide partial implementation (how to do).
LRU Cache (Hash Map + Doubly Linked List)
class LRUCache {
class Node {
int key, value;
Node prev, next;
}
private Map<Integer, Node> map = new HashMap<>();
private Node head, tail;
private int capacity;
public int get(int key) {
if (!map.containsKey(key)) return -1;
Node node = map.get(key);
remove(node);
addAtHead(node);
return node.value;
}
public void put(int key, int value) {
if (map.containsKey(key)) remove(map.get(key));
if (map.size() == capacity) {
map.remove(tail.prev.key);
remove(tail.prev);
}
Node newNode = new Node();
newNode.key = key; newNode.value = value;
map.put(key, newNode);
addAtHead(newNode);
}
}Trie Implementation (Insert/Search)
class TrieNode {
public:
TrieNode* children[26];
bool isEndOfWord;
TrieNode() {
isEndOfWord = false;
for (int i = 0; i < 26; i++) children[i] = nullptr;
}
};
class Trie {
TrieNode* root;
public:
Trie() { root = new TrieNode(); }
void insert(string word) {
TrieNode* curr = root;
for (char c : word) {
if (!curr->children[c - 'a']) curr->children[c - 'a'] = new TrieNode();
curr = curr->children[c - 'a'];
}
curr->isEndOfWord = true;
}
};Operating System Basics
Scheduling, deadlock and memory management essentials.
Concurrency & OS
- • Process vs Thread memory sharing
- • Mutex vs Semaphore for synchronisation
- • Deadlock conditions (Circular Wait, No Preemption, etc.)
- • Paging and Virtual Memory management
- • Context switching overhead
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Core DSA (Arrays, Strings, LL)
- 2–3 problems on sliding window, two pointers, and linked list reversal
Goal: Master linear data structures and complexity analysis.
Non-Linear DS (Trees, Graphs)
- BFS/DFS on trees/grids, LCA, and topological sort
Goal: Understand hierarchical and networked data processing.
Optimization (DP, Heaps)
- Common DP patterns (Knapsack, LCS) and Heap-based problems
Goal: Solve complex optimization and top-K element problems.
Advanced & Design (L3)
- Segment trees, Tries, and System Design basics
Goal: Prepare for hard follow-ups and architectural discussions.
Googliness & Mocks
- STAR story preparation and 45-min timed mock interviews
Goal: Refine communication and behavioural responses.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Coding Rounds: Ask clarifying questions → Brute force → Optimise → Dry run. Think out loud constantly.
- System Design: Define requirements first. Draw high-level blocks. Discuss trade-offs and failures.
- Googliness: Use STAR. Focus on your specific contribution and what you learned from failures.
Coding time split (50 min)
- 5 min: Clarification
- 10 min: Logic/Pseudocode
- 20 min: Coding
- 10 min: Testing
Interview Process
What follows the online test.
Recruiter / Phone Screen
- • Initial screening for DSA
- • Communication check
- • Basic problem solving
On-site Loop
- • Deep-dive DSA with hard follow-ups
- • System design (L3)
- • Googliness / Cultural fit
Hiring Committee
- • Independent packet review
- • Final hiring recommendation based on all rounds
Mock Test Plan
Four simulations to run before the real test.
Google Coding Mock (Medium-Hard)
- • Two problems
- • 45 mins each
- • Focus on optimal O-notation
L3 System Design Mock
- • Design a rate limiter
- • Scalability discussion
- • Trade-off analysis
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Google process.
Be the first to share a Google interview experience.
Frequently Asked Questions
Is LeetCode enough for Google?
Yes, but focus on the 'why' and be prepared for multiple follow-up constraints.
How important is communication?
Crucial. Google evaluates 'how' you solve the problem as much as the solution itself.
What is a 'Googliness' round?
A behavioural round assessing leadership, ethics, and ability to handle ambiguity.
Want the full structured prep for Google?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Google pattern and other Big Tech / Product recruiters.
Other Big Tech / Product companies
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.
Computer Networks Essentials
OSI vs TCP/IP, HTTP, DNS and the networking questions freshers actually get.
Recommended practice path