Google Interview Prep Guide

Front End or Mobile Software Engineer

What’s a Software Engineer (SWE)?

Software Engineers at Google develop the next-generation technologies that change how
millions of users connect, explore and interact with information and one another. As a Front End
SWE, you’ll specialize in building responsive and elegant web applications that scale to millions
of users in dozens of languages. As a Mobile SWE, you’ll build iOS or Android applications used
around the world. In both roles, you’ll help Google build next-generation web applications like
Gmail, Google Search, Google Maps and more.

Why Google? Impact.

Google is and always will be an engineering company. We hire people with a broad set of
technical skills who are ready to tackle some of technology's greatest challenges and make an
impact on millions, if not billions, of users. At Google, engineers not only revolutionize search,
they routinely work on massive scalability and storage solutions, large-scale applications and
develop entirely new platforms around the world. From AdWords to Chrome, Android to
YouTube, Cloud to Maps, Google engineers are changing the world one technological
achievement after another.

careers.google.com
General Interview Tips
Explain - We want to understand how you think, so explain your thought process and decision
making throughout the interview. Remember we’re not only evaluating your technical ability,
but also how you solve problems. Explicitly state and check assumptions with your interviewer
to ensure they are reasonable.
Clarify - Many questions will be deliberately open-ended to provide insight into what
categories and information you value within the technological puzzle. We’re looking to see how
you engage with the problem and your primary method for solving it. Be sure to talk through
your thought process and feel free to ask specific questions if you need clarification.
Improve - Think about ways to improve the solution you present. It’s worthwhile to think out
loud about your initial thoughts to a question. In many cases, your first answer may need some
refining and further explanation. If necessary, start with the brute force solution and improve
on it — just let the interviewer know that's what you're doing and why.
Practice - You won’t have access to an IDE or compiler during the interview so practice writing
code on paper or a whiteboard. Be sure to test your code and ensure it’s easily readable
without bugs. Don’t stress about small syntactical errors like which substring to use for a given
method (e.g. start, end or start, length) — just pick one and let your interviewer know.

The Technical Phone Interviews

Your phone interview will cover data structures and algorithms. Be prepared to write around
20-30 lines of code in your strongest language. Approach all scripting as a coding exercise —
this should be clean, rich, robust code.

1. You will be asked an open-ended question. Ask clarifying questions, devise

requirements.
2. You will be asked to explain it in an algorithm.
3. Convert it to a workable code. Hint: Don't worry about getting it perfect because time is
limited. Write what comes but then refine it later. Also make sure you consider corner
cases and edge cases, production ready.
4. Optimize the code, follow it with test cases and find any bugs.
The Coding & Algorithm Interviews
Coding - You should know at least one programming language well, preferably JavaScript (for
Front End SWEs), Java or Kotlin (for Android SWEs) or Objective-C or Swift (for iOS SWEs).
You’ll be expected to know APIs, Object Oriented Design and Programming, how to test your
code, as well as come up with corner cases and edge cases for code. Note that we focus on
conceptual understanding rather than memorization.
Algorithms - Approach the problem with both bottom-up and top-down algorithms. You will
be expected to know the complexity of an algorithm and how you can improve/change it.
Algorithms that are used to solve Google problems include sorting (plus searching and binary
search), divide-and-conquer, dynamic programming/memoization, greediness, recursion or
algorithms linked to a specific data structure. Know Big-O notations (e.g. run time) and be
ready to discuss complex algorithms like Dijkstra and A*. We recommend discussing or
outlining the algorithm you have in mind before writing code.
Sorting - Be familiar with common sorting functions and on what kind of input data they’re
efficient on or not. Think about efficiency means in terms of runtime and space used. For
example, in exceptional cases insertion-sort or radix-sort are much better than the generic
QuickSort/MergeSort/HeapSort answers.
Data structures - You should study up on as many data structures as possible. The data
structures most frequently used are arrays, linked lists, stacks, queues, hash-sets, hash-maps,
hash-tables, dictionary, trees and binary trees, heaps and graphs. You should know the data
structure inside out, and what algorithms tend to go along with each data structure.
Mathematics - Some interviewers ask basic discrete math questions. This is more prevalent at
Google than at other companies because counting problems, probability problems and other
Discrete Math 101 situations surround us. Spend some time before the interview refreshing
your memory on (or teaching yourself) the essentials of elementary probability theory and
combinatorics. You should be familiar with n-choose-k problems and their ilk.
Graphs - Consider if a problem can be applied with graph algorithms like distance, search,
connectivity, cycle-detection, etc. There are three basic ways to represent a graph in memory
(objects and pointers, matrix, and adjacency list) — familiarize yourself with each
representation and its pros and cons. You should know the basic graph traversal algorithms,
breadth-first search and depth-first search. Know their computational complexity, their
tradeoffs and how to implement them in real code.
Recursion - Many coding problems involve thinking recursively and potentially coding a
recursive solution. Use recursion to find more elegant solutions to problems that can be solved
iteratively.
Front End & Mobile Technical Interview
Web Front End - You should be ready to cover topics like front end latency and implementation
of standard CS algorithms using idiomatic JavaScript. You should be able to articulate
Javascript strengths and shortcomings and ready to cover any of the following:
● Browser / DOM events & event handling
● Web security issues (XSS, XSRF)
● XHR requests & HTTP headers ●
● Prototypal inheritance
JavaScript closures
● DOM API & manipulation ●
CSS manipulation

Mobile (Android or iOS) - We may ask you questions that fall into the following mobile
development topic areas:
● Frameworks and/or dependency
● Performance
injection
● Runtime, memory, battery life,
● Mobile application design
multithreading
○ App architecture (e.g., MVP,
● UI, view hierarchy, native APIs
MVVM, etc.)
● Concurrency and threading primitives
○ Storage mechanisms
○ Network layer

Be ready to cover implementation of standard CS algorithms using idiomatic mobile Java,

Kotlin, Obj-C or Swift and have awareness of your chosen language’s strengths and
shortcomings. You should know how to:

● Split tasks in a UI-friendly way (e.g. threading/GCD, not stopping the UI thread, etc.)
● Structure APKs for a large application, managing permissions
● Build offline functionality
● Leverage Intents and Intent Filters

Focus on translating ideas to code. You should grasp basic data structures available in
Foundation (NSArray, NSDictionary, NSSet) and block usage (no, you don't have the memorize
the block syntax!). Demonstrate the ability to write code to do client/server interactions and
understand limitations and system behaviors. Understand key language features like memory
management model, object-oriented features, protocols, delegates, categories, Grand Central
Dispatch and performance. You should also demonstrate ability to create screens in UIKit,
understanding of View Controller concepts, UIView structure and best practices. Understand
how to create a view controller and layout subviews.
Front End or Mobile Design Interview* - Design questions are used to assess a candidate's
ability to combine knowledge, theory, experience and judgement toward solving a real-world
engineering problem. Sample topics include Web App, Mobile App and API design (where the
front-end and the back-end meet).

*For senior candidates only. Consult with your recruiter for additional details.

Resources

About Google Interview Prep

Company - Google How we hire
The Google story Interviewing @ Google
Life @ Google