Software Engineer Interview Prep

The short answer: Most software engineer interviews at large tech companies follow the same arc: a recruiter call, a technical screen, then a loop of about three to six interviews covering coding, system design from mid-level up, and behavioral questions. What differs is the detail: who decides, whether your code runs, whether AI is allowed, and how much weight values carry. This guide compares ten companies stage by stage, maps their levels and posted pay, and lays out a 12-week plan. Last reviewed October 2026.

Software engineer interview: quick answers

How ten companies run the software engineer interview

The short version of each process. Each company guide has the full detail, with links to the company's own pages.

The interview, stage by stage

The names differ, but almost every loop has the same five stages. Here is what happens in each, and where companies break the pattern.

The recruiter call

The first call is 15 to 30 minutes with a recruiter, sometimes an engineer at Bloomberg. It is a fit check: your background, the kind of work you want, location, timing and, often, pay expectations.

It feels informal, but it shapes the rest of the process. The recruiter decides which level you are screened for, and at Amazon that level decides which loop you get. Ask what the loop looks like, which languages are fine and whether any round is unusual for that team.

Have a two-minute summary of your work ready. Lead with scope and results rather than a list of technologies.

The online assessment

Amazon and Microsoft often start with an online coding assessment. Google gives one to some candidates, mostly new grads and interns, and Meta to some candidates. Expect two problems in 60 to 90 minutes. Amazon's SDE II version adds system design scenarios and a work style survey, and its new grad version adds a Work Simulation of realistic Amazon situations.

Nobody watches you think here, so the code itself is the signal. Correct output on hidden test cases matters most, then clean code. Treat the work style questions seriously too: they are built on the company's values.

The technical screen

This is the first real filter. It is usually one 45 to 60 minute video call with an engineer in a shared editor. Meta asks two problems in about 35 minutes. Google uses a shared document with no code execution. Stripe gives a practical multi-part problem and lets you use your own IDE. Uber's one-hour screen covers coding and design, and Uber says it sets your starting level.

Interviewers score more than the answer. Meta lists communication, problem solving, coding and verification. Google says it cares more about how you get there than the final answer. Both point the same way: talk through your plan, write clean code and test it before saying you are done.

The interview loop

The loop, still called the onsite even when it runs over video, is three to eight interviews in one or two days. Most loops mix three kinds of round.

Coding. Two or three rounds of data structures and algorithms at medium to hard difficulty. A few companies swap one for a practical round: Stripe runs a bug bash in an unfamiliar repository and an integration round against an API, Uber's second coding round tests depth in your specialty, and Netflix and Apple teams often set problems from their own domain.

System design. One or two rounds from mid-level up. Meta splits design into Systems Design and Product Architecture Design depending on the role. Netflix candidates call design the round that carries the most weight.

Behavioral. At least one round on how you work: conflict, ownership, ambiguity and impact. Amazon asks Leadership Principle questions in every interview, Airbnb runs two core values interviews, and Uber's Collaboration and Leadership interview is one of its three.

The decision

Who decides varies more than anything else in the process. At Google, a separate review that did not interview you reads the packet and confirms your level, and you still need a team match. At Amazon, a Bar Raiser from outside the team decides with the hiring manager. At Uber, a trained Bar Raiser moderates the debrief toward a consensus. At Stripe, the panel reaches consensus from written feedback.

Some loops end early. Apple and Bloomberg teams can stop the onsite after a weak round, and a poor round with one Bloomberg team can make other teams decline to interview you.

Clearing every round is not always an offer either. Google and Meta match you to a team after the loop, and Apple also weighs your level and open headcount.

Levels across companies

Your level decides which loop you get, how hard the design round is and the pay band of the offer. Titles line up only roughly: scope and pay at the same tier can differ a lot, and Bloomberg does not publish levels. The company guides explain each ladder.

Interviews change with the level. Entry loops are mostly coding. Mid-level loops add a design round. Senior loops raise the design bar and look for ownership beyond your own code. Staff loops weigh design and leadership most, and some change format: Amazon's SDE III loop starts with a phone screen with a senior leader, and Stripe asks Staff candidates for a written one-pager.

Pay in US job postings

US base salary ranges from each company's own job postings, seen October 27, 2026. Bonus and stock come on top at every company except Netflix, which posts its full salary. Ranges are wide because one posting covers many locations and levels of experience. Each company guide links the postings.

Meta's postings list years of experience instead of levels: $154K to $217K for 5 to 6 or more years, $184K to $257K for 8 or more, and $219K to $301K for 12 or more. Microsoft's figures are its US typical ranges; the San Francisco Bay Area and New York ranges are higher. Stripe's mid-level row is a Seattle posting with no level in the title.

The coding interview

What interviewers score

Getting the right answer is necessary but not enough. Across these companies the same four things come up: whether you understood the problem before coding, whether you found a sound approach and could explain its cost, whether the code is correct and readable, and whether you tested it without being asked.

Companies differ on the tools. Microsoft's interview tool compiles and runs your code. Google's phone screen and Meta's loop do not, so you trace test cases by hand. Amazon and Microsoft rule out pseudocode, and Airbnb expects code that passes tests.

Meta's own guide says it does not ask dynamic programming questions. That is the only company here to rule out a topic in writing.

The topics that come up

Most algorithm rounds draw from a short list: arrays and hashing, two pointers, sliding windows, stacks, binary search, trees, graphs (BFS, DFS and topological sort), heaps, intervals and, outside Meta, dynamic programming. Graph problems are the single biggest group among the problems our team has tagged for these ten companies.

Practical rounds draw on different skills. Stripe, Uber and Airbnb lean toward realistic tasks: a rate limiter, a retry queue, idempotent writes, a job scheduler or debugging a broken parser. Practice reading unfamiliar code and adding tests, not only solving puzzles from a blank file.

How to run a 45-minute round

Minutes 0 to 5: clarify. Restate the problem, ask about input size, edge cases and what to return, and write one small example.

Minutes 5 to 12: plan. Say the brute force approach and its cost, then improve it. Agree on the approach with the interviewer before writing code. A hint at this stage costs much less than one later.

Minutes 12 to 32: code. Write it in clear, named pieces. Keep talking, but in short updates rather than narrating every keystroke.

Minutes 32 to 40: test. Walk your example through the code line by line, then try an empty input, one element, duplicates and the largest case. Fix bugs out loud.

Minutes 40 to 45: wrap up. State the time and space complexity and one way you would extend it. Meta asks two problems per round, so at Meta halve every block above.

A worked example

The problem: Given a list of meetings as (start, end) times, return the fewest rooms needed so that no two overlapping meetings share a room. A meeting that ends at 10 frees its room for one that starts at 10.

1. Clarify. Are the times integers? Can the list be empty (answer 0)? Is the input sorted? Here it is not. Does end at 10 and start at 10 count as an overlap? The problem says no.
2. Brute force. For every meeting, count how many others overlap its start time and take the maximum. That is O(n squared). It works, so say it, then improve it.
3. Better idea. Process meetings in start order and keep the end times of the rooms in use. When a meeting starts, if the earliest-ending room is already free, reuse it; otherwise open a new room. A min-heap gives the earliest end time in O(log n).
4. Complexity. Sorting is O(n log n) and each heap operation is O(log n), so O(n log n) time and O(n) space in the worst case, when every meeting overlaps.
5. Test. [] gives 0. [(0, 30), (5, 10), (15, 20)] gives 2. [(1, 5), (5, 10)] gives 1, because the second meeting reuses the room. [(1, 10), (2, 3), (4, 5), (6, 7)] gives 2.
6. Follow-ups. Interviewers often ask which room each meeting gets (store room ids in the heap with the end time), or how to handle meetings arriving as a stream (the same heap works, one meeting at a time).

import heapq

def min_rooms(meetings):
    """Fewest rooms so that no two overlapping meetings share one. End times are exclusive."""
    ends = []  # end times of the rooms in use, earliest first
    for start, end in sorted(meetings):
        if ends and ends[0] <= start:
            heapq.heapreplace(ends, end)  # the earliest room is free: reuse it
        else:
            heapq.heappush(ends, end)     # every room is busy: open a new one
    return len(ends)

The code is short. The interview is the six steps around it, so practice saying them as much as writing the code.

The system design interview

When system design starts

New grad loops are mostly coding. Design usually starts at mid-level and gets heavier with each level. Amazon includes at least one design question from SDE II, candidate guides put Meta's first design round at E4 and Google's at L5, and Stripe's design round starts at mid-level.

At staff level the format can change. Stripe replaces the integration round with a written one-pager on a past project that you present to a staff engineer, and Uber looks for leadership signal as well as design depth.

A framework for a 45-minute design round

Requirements (5 minutes). Agree on the core features, the users and the scale: requests per second, data size, read to write ratio and latency targets. Write the numbers down.

API and data model (5 to 10 minutes). Define the main endpoints and the records you store. Stripe puts extra weight on API design, so spend longer here there.

High-level design (10 minutes). Draw clients, load balancers, services, storage, caches and queues. Walk one request through the diagram end to end.

Deep dive (15 minutes). Pick the hardest part, or let the interviewer pick, and go deep: partitioning, consistency, hot keys, failure handling or how you would roll out a change.

Wrap up (5 minutes). Name the bottlenecks, what you would monitor and what you would change at ten times the scale.

What design prompts look like

Prompts tend to come from the company's own products. Our practice prompts follow the same idea: matching riders with nearby drivers for Uber, webhook delivery to merchants for Stripe, streaming live prices to terminals for Bloomberg, and a booking flow that prevents double bookings for Airbnb. Each company guide has five prompts with answer outlines.

The common failures are the same everywhere: jumping to components before agreeing on requirements, a design with no numbers behind it, and a deep dive that never gets deep. At senior levels, interviewers also expect you to bring up trade-offs before they ask.

The behavioral interview

Every company here has at least one behavioral round, and at several companies it can block an offer on its own. Each one grades against its own framework.

Build a story bank

Write six to eight stories from your recent work: a conflict, a failure, a decision with incomplete data, a time you led without authority, a time you raised the quality bar and your biggest result. Each story can answer several questions.

Tell each one in STAR form in about three to four minutes. Amazon's guidance is useful anywhere: say "I" rather than "we", give numbers and use different stories for different questions. Microsoft adds a Reflection at the end, which is worth copying.

Then map the stories to each company's framework. The same story about fixing a flaky release process can show Amazon's Insist on the Highest Standards, Meta's driving results and Airbnb's Be a Host, with a different emphasis each time.

Senior candidates need scope in their stories. Stripe candidates report being leveled down when their answers showed execution but not the impact expected at the target level.

AI tools in interviews

Rules on AI differ more than anything else right now, so ask your recruiter.

Meta says many of its interviews include a built-in AI assistant that candidates are expected to use, in coding and in design. Outside AI tools are not allowed. Candidate reports list letting the assistant write the whole solution as a reason for rejection, so drive it the way you would a fast junior teammate.

Google says AI tools and Google Search are not allowed. News reports describe a pilot code comprehension round on some US teams where candidates may use Gemini, but most candidates will not see it.

Uber rules out AI unless your recruiter says otherwise, and some of its technical interviews provide an AI agent in the coding environment. Microsoft says not to use outside help such as AI unless the interviewer allows it. At Stripe and Apple, candidates report that AI tools are not allowed.

Why candidates get rejected

The reasons below come up again and again in the company guides. Most are about how you work through the problem, not whether you know the answer.

• Coding without clarifying. Google, Amazon and Microsoft all list it. Two minutes of questions saves ten minutes of rewriting.
• Working in silence. Interviewers cannot give credit for reasoning they cannot hear, and they cannot give you hints either.
• No testing. Correct code that was never traced reads as luck. Google's phone screen has no code execution, so hand tracing is the test.
• Design below the level. Meta and Airbnb candidates report it as a common reason for rejection, especially above mid-level.
• Weak values or behavioral signal. Airbnb's core values interviews and Netflix's culture rounds can sink an offer after strong technical rounds.
• Vague stories. Rambling, "we" instead of "I", and no numbers. Amazon lists all three.
• A generic "why us". Apple candidates name it as a red flag, and Uber asks why you want Uber beyond the brand.

A 12-week prep plan

A plan for a mid-level candidate with a full-time job, about 10 to 12 hours a week. Compress it if your interviews are sooner.

New grads can fold the design weeks into more coding and a stronger project story. Senior and staff candidates should start design in week 3 and run it alongside coding, since design and leadership signal decide their level.

Courses for each round

• Data Structures and Algorithms
• System Design
• Modern C++
• C#
• Rust

Practice questions

Coding problems our team tagged for two or more of these companies, then design, fundamentals and behavioral prompts we wrote for practice.

1from typing import List, Tuple
2
3def files_to_rebuild(imports: List[Tuple[str, str]], changed: str) -> List[str]:
4    """Return every file that depends on `changed`, directly or indirectly, sorted."""
5    pass

1from collections import defaultdict, deque
2from typing import List, Tuple
3
4def files_to_rebuild(imports: List[Tuple[str, str]], changed: str) -> List[str]:
5    importers = defaultdict(list)  # file -> files that import it (the reverse edges)
6    for a, b in imports:
7        importers[b].append(a)
8    seen = {changed}
9    queue = deque([changed])
10    while queue:
11        for parent in importers[queue.popleft()]:
12            if parent not in seen:  # the seen set also makes cycles safe
13                seen.add(parent)
14                queue.append(parent)
15    seen.discard(changed)
16    return sorted(seen)
17
18# O(V + E) to build the reverse graph and walk it, plus O(k log k) to sort the k results.

Company guides

Read the guide for each company you are interviewing with:

• Google: phone screen, panel, a separate review of your packet and team matching.
• Meta: two-problem screen, the full loop and the built-in AI assistant.
• Amazon: online assessment, Leadership Principles and the Bar Raiser.
• Microsoft: team-by-team loops, code that runs and STAR(R) answers.
• Apple: team-owned loops and the weight of "Why Apple?".
• Netflix: the culture memo, director interviews and the design round.
• Uber: three onsite interviews, the specialty round and the Bar Raiser debrief.
• Airbnb: real code only and the core values interviews.
• Bloomberg: two engineers per round and a choice of paper, whiteboard or laptop.
• Stripe: bug bash, integration and practical coding rounds.