Skip to main content
New Grad Software Engineer

What do new grad software engineer interviews ask?

A new grad software engineer loop is usually a recruiter call, one or two coding rounds, a conversation about the most substantial thing you have built, and a behavioral round about working with other people. Compared with an internship it asks for more: you are expected to write clean, tested code without much prompting, to reason about how a small system fits together, and to show you can take feedback and own a result. Nobody expects you to have run production systems, but they do expect you to have thought about what happens when something you built fails.

New Grad Software Engineer interview questions, by round

20 questions across 5 rounds.

Recruiter and hiring manager screen

Confirms your timeline, your interests and whether your story about your own work holds together before the technical rounds begin.

  1. What kind of problems do you want to be working on in your first two years?
  2. Which project in your degree or on your own are you proudest of, and what was your part in it?
  3. What are you looking for in a first team that you could not get anywhere else?
  4. Do you prefer building new features or improving what exists, and why?

Data structures and algorithms

Medium-difficulty problems in a shared editor. The interviewer watches how you structure the solution, handle edge cases and respond to a hint.

  1. Design an LRU cache with constant-time get and put.
  2. Given a list of meeting intervals, merge the overlapping ones.
  3. Find the k most frequent words in a large list of words.
  4. Detect whether a directed graph of course prerequisites has a cycle.
  5. Serialize and deserialize a binary tree.
  6. Given a rotated sorted array, find a target value in logarithmic time.

Practical coding and code review

Closer to daily work: read some existing code, find what is wrong with it, or extend it without breaking its tests.

  1. Here is a function with a bug that only appears on empty input. Find it and fix it.
  2. Review this pull request and tell me what you would ask the author to change.
  3. Add pagination to this endpoint without changing its existing behavior.
  4. How would you write tests for a function that calls an external payment service?

Light system design

A small, bounded design problem. Interviewers look for sensible components and trade-offs, not a complete architecture.

  1. Design a URL shortener: what do you store, and how do two requests for the same link behave?
  2. Design the backend for a notification feature that sends email and push messages.
  3. How would you add rate limiting to a public API?

Behavioral and collaboration

Tests how you work with reviewers, teammates and ambiguity, using the situations you actually lived through at school, internships or open source.

  1. Tell me about a time you disagreed with a teammate about a technical approach.
  2. Describe feedback on your code that changed how you write it.
  3. Tell me about a deadline you missed or nearly missed, and what you did about it.

Sample answers

Illustrative answers written for this guide, not transcripts of real candidates.

Design an LRU cache with constant-time get and put.

I would clarify capacity and whether keys and values are arbitrary, then say what I need: constant-time lookup, and constant-time reordering when something is used. A hash map alone gives me lookup but no order. A doubly linked list gives me order and cheap removal if I already hold the node. So I combine them: the map goes from key to list node, and the list keeps most recently used at the head. On get, I look up the node, move it to the head and return the value. On put, I update and move to head if the key exists; otherwise I insert at the head, and if I am over capacity I drop the tail node and delete its key from the map. Dummy head and tail nodes remove the null checks. I would test capacity one, a repeated put on the same key, and a get that changes which entry gets evicted.

Why it scores: Problem-Solving: derives the structure from the two requirements instead of reciting it. Technical: both complexities are justified and eviction is handled on both structures. Code Quality: the sentinel nodes and the chosen tests show care for edge cases.

Tell me about a time you disagreed with a teammate about a technical approach.

In my capstone, my teammate wanted to store every sensor reading in one large table and filter in the app, and I wanted to aggregate in the database. Instead of arguing about it, I proposed we measure. I wrote a small script that loaded a realistic day of data and timed both approaches on the dashboard query. His approach was fine at the size we had, mine was clearly better at the size we expected by demo day. We agreed on mine, but kept his simple model for the rarely used export page, which made it a real compromise. The part I took away was to bring a measurement to a disagreement, not just an opinion, and to leave the other person with something they were right about.

Why it scores: Behavioral: a real conflict with a specific resolution and a concession from both sides. Communication: shows how to disagree without making it personal. Problem-Solving: turns an opinion contest into a test.

Review this pull request and tell me what you would ask the author to change.

I read the description first to see what it is meant to do, then the tests, then the code. Here, the new function mutates the list that the caller passed in, which is surprising and would break the report that reuses it, so I would ask for a copy or a clear name. There is no test for the empty list, which is the case I would worry about most. One variable is named data2, so I would suggest a name that says what it holds. I would separate what must change before merging, like the mutation and the missing test, from what is a preference, like the name, and I would phrase it as questions where I am not sure, such as asking whether the caller relies on the order. Finally I would say what I liked, because the author split the parsing out nicely.

Why it scores: Code Quality: finds a real defect and a missing edge-case test, not only style. Communication: separates blocking issues from preferences and keeps the tone collaborative. Technical: names the consequence of the mutation for a specific caller.

How would you add rate limiting to a public API?

First I would ask what we are protecting against: one noisy client, or abuse from many. For the first, I would limit per API key, and for anonymous traffic per IP address. A token bucket suits it, because it allows short bursts while holding the average rate. With one server I could keep the buckets in memory; with several, the counters have to be shared, for example in Redis with an atomic increment and an expiry. When a client is over the limit I return a 429 with a Retry-After header so well-behaved clients back off. I would put it in middleware so every route gets it, make the limits configurable per route, and log rejections so I can see whether the limits are too tight. I would be careful about IPs behind a shared proxy, which can lump many real users together.

Why it scores: Technical: picks an algorithm for a stated reason and handles the multi-server case. Problem-Solving: starts from the threat, not the tool. Communication: covers client behavior and observability, which a bounded design answer should touch lightly.

What a New Grad Software Engineer answer is scored on

Problem-Solving
Do you break a large problem into parts, pick a data structure for a reason you can state, and adjust when a hint arrives? New grads are expected to need fewer hints than interns.
Code Quality
Code another engineer could maintain: clear names, no duplicated logic, and tests you choose that hit empty input, limits and failure paths. Reviewing code well counts here too.
Technical
Correct complexity, working knowledge of storage, networking and concurrency basics, and enough design sense to name the main trade-off in a small system.
Communication
Stating assumptions, narrating your reasoning, and explaining a design so that a teammate who did not see your work could follow it.
Behavioral
Evidence that you take feedback, handle disagreement and own mistakes, told through specific situations and what you changed afterwards.

These are the five dimensions every interview rolls up to. The full rubric and its measured limits are on the scoring page.

How a Lifelike New Grad Software Engineer interview is scored

How a Lifelike New Grad Software Engineer interview is scored: a live voice interview, graded on the rubric for its type with an overall score out of 100, calibrated and banded into YES, MAYBE or NO, then rolled up onto the Profile Card across five dimensions (Technical, Problem-Solving, Communication, Code Quality, Behavioral).
The same rubric grades every Lifelike interview. See the full rubric

What the report shows you

Sample report Performance snapshot: strengths and improvement actions, each quoting the exact sentence from the interview it came from, tagged with its question number.
Sample report, synthetic data. Every strength and gap quotes the moment it came from.

How to prepare

  • Practise the medium-difficulty patterns until you can state the data structure choice in one sentence: heap, hash map plus list, union-find, topological sort, binary search on an answer.
  • Review code on purpose. Read a real open-source pull request and write three comments, separating blocking issues from preferences.
  • Prepare a one-page account of your biggest project: the data model, one decision you would reverse, and one failure you handled.
  • Do two or three small design exercises out loud: a URL shortener, a notification service, a rate limiter. Name components, one trade-off and what you would measure.
  • Write down four behavioral stories with your own actions and the change afterwards, including one where you were wrong.

New Grad Software Engineer interviews: common questions

How is a new grad software engineer interview different from an internship interview?

The coding bar is similar, but a new grad is expected to produce cleaner, better-tested code with fewer hints, and there is often a light design round and a code review exercise that internships usually skip. The behavioral round also looks for how you handle feedback and ownership.

Do new grads get system design questions?

Usually a small, bounded one. You are not expected to design a global distributed system. You are expected to identify the main components, say how data is stored, and name one trade-off and one thing that could fail.

What if my only experience is coursework and personal projects?

That is the normal case. Pick the project where you made the decisions and can explain what you would change. Interviewers care more about your depth on one real project than about how many you list.

How do I practise?

Run a mock interview for the Software Engineer role, answer out loud and read the feedback report. Each answer is scored on the five dimensions above, with the transcript shown beside the score.