# Software engineer interview questions and how to prepare

> What software engineering interviews ask in coding, system design and behavioral rounds, which topics to review, how answers are judged, and sample answers.

- Canonical URL: https://jobbie.bot/blog/software-engineer-interview-questions
- Topic: [Interviews](https://jobbie.bot/guides/interviews)
- Published by [Jobbie](https://jobbie.bot/) · Updated 2026-10-06 · 8 min read

Software engineer interviews ask three kinds of questions: coding problems you solve live or in a timed online test, system design discussions (mostly for mid-level and senior roles) and behavioral questions about how you work. In the technical rounds, interviewers evaluate how you reach an answer as much as the answer itself: whether you clarify the problem, explain your approach, write working code, test it and reason about its cost.

Prepare by reviewing data structures and algorithms, practicing aloud without an editor’s help, and preparing a few stories about real projects.

## Key takeaways

- Coding rounds reward a visible process: clarify, plan aloud, code, test, then state the time and space cost.
- Review the core data structures and algorithms until you can say what each operation costs.
- System design is typically for mid-level and senior roles. Junior candidates are more likely to get object-oriented design or a scaled-down version.
- Practice the way you will be tested: aloud, timed, and without autocomplete.
- Behavioral questions count. Prepare stories about a hard bug, a design disagreement and a project you led.

## What software engineer interviews include

Expect some combination of these stages.

- **Online coding assessment.** A time-limited test on a coding platform, used early to check that you can write correct code quickly.
- **Technical screen.** A live interview in which you write code while walking the interviewer through your thinking.
- **Coding and design rounds.** Several interviews in one day, on site or by video. The design round may be system design or object-oriented design.
- **Behavioral round.** Open-ended questions about your past experience.

[How to prepare for a technical interview](https://jobbie.bot/blog/technical-interview-preparation) covers each format, including take-home projects.

## Software engineer interview questions by what they test

**Coding: data structures and algorithms**

- Given a list of integers and a target, return the positions of two numbers that add up to the target.
- Determine whether a string of brackets is balanced.
- Reverse a linked list.
- Find the first character in a string that does not repeat.
- Merge a list of overlapping intervals.
- Find the shortest path between two cells in a grid with obstacles.
- Check whether a binary tree is a valid binary search tree.

**Computer science fundamentals**

- How does a hash table work, and what happens when two keys collide?
- What is the difference between a process and a thread?
- What happens between typing a web address and seeing the page?
- What is a database index, and what does it cost?

**System design**

- Design a URL shortener.
- Design a rate limiter for a public API.
- Design a chat service that delivers messages in order.
- The database has become the bottleneck of a growing service. What are your options?
- Design the classes for a parking garage.

**Code quality, testing and debugging**

- How would you test the function you just wrote?
- Walk me through a production issue you debugged.
- Here is a pull request. What would you change?

**Behavioral**

- Tell me about the most technically difficult project you have worked on.
- Tell me about a time you disagreed with a teammate about a design.
- Tell me about a bug you shipped. What happened next?
- Tell me about a time you had to learn a technology quickly.

## Topics to review

Amazon publishes the topic list it gives software development candidates: a programming language, data structures, algorithms, coding, object-oriented design, databases, distributed computing, operating systems, internet topics, and general machine learning and artificial intelligence.

| Area | What to be able to do |
| --- | --- |
| One programming language | Write correct code from memory: strings, collections, sorting, classes, error handling |
| Data structures | Arrays, hash maps and sets, linked lists, stacks, queues, trees, heaps and graphs: what each is for and what its operations cost |
| Algorithms | Sorting, binary search, breadth-first and depth-first search, recursion, two pointers, basic dynamic programming |
| Complexity | State the time and space cost of your own code in Big-O terms, and the trade-off between them |
| Object-oriented design | Turn a small problem into classes with clear responsibilities |
| Systems | Databases and indexes, caching, queues, load balancing, replication, how web requests work |
| Testing and debugging | Edge cases, unit tests, reading a stack trace, narrowing down a failure |

Amazon adds that its interviewers are not checking whether you memorized every detail, but whether you can apply what you know to solve problems efficiently. It also recommends practicing outside an integrated development environment.

## How interviewers evaluate you

Carnegie Mellon’s career center tells its computer science students that interviewers look at how a candidate thinks through a problem, and that the focus may be more on the process than on the outcome.

| What is evaluated | What a strong candidate does |
| --- | --- |
| Problem solving | Restates the question, asks about inputs and edge cases, and compares more than one approach |
| Communication | Talks through the reasoning, so the interviewer never has to guess |
| Coding | Writes working, readable code in the language they chose |
| Verification | Runs through examples by hand and finds their own bugs |
| Analysis | States time and space complexity and what they would trade |
| Collaboration | Asks for help when stuck and responds well to hints and feedback |

In a design round the same list applies at a larger scale: requirements first, a simple design before a clever one, then trade-offs. Carnegie Mellon also warns against pretending to know something you do not. Say what you do know and reason from there.

## Sample answers to software engineer interview questions

```Sample answer: “Find the first character in a string that does not repeat”
Two questions first. Are upper and lower case different characters? And what should I return if every character repeats? I'll assume case matters and return None.

The brute-force way compares each character with every other one, which is O(n^2). I can do better by counting each character in one pass, then scanning again for the first one with a count of 1.

from collections import Counter

def first_unique_char(s):
    counts = Counter(s)
    for ch in s:
        if counts[ch] == 1:
            return ch
    return None

Let me test it. "swiss" gives "w". "aabb" gives None. An empty string skips the loop and gives None.

That's two passes, so O(n) time, and O(k) extra space for k distinct characters.
```

Why it works: the candidate clarifies, names the simple solution before the better one, tests edge cases unprompted and finishes with complexity.

```Sample answer: “Design a URL shortener” (the first five minutes)
Let me pin down requirements before I draw anything. We need to create a short link from a long URL and redirect a short link to the original. Redirects must be fast and highly available, and I'd expect far more redirects than new links. Can I assume about 100 million new links a month?

The API is small: a POST that takes a long URL and returns a short code, and a GET on the code that redirects.

For storage, one record per code holding the long URL. Every read is a lookup by key, so a key-value store fits.

For the code, I'd give each link a unique numeric ID and encode it in base 62. Seven characters cover about 3.5 trillion links.

Because reads dominate, I'd put a cache in front of the store. Which part should I go deeper on: generating IDs across servers, caching or abuse?
```

Why it works: requirements and scale come first, each choice has a reason, and the candidate hands the interviewer a choice of where to dig.

```Sample answer: “Tell me about a bug you shipped”
Last spring I shipped a change to our checkout service that rounded tax per line item instead of per order. For about three hours, some orders were overcharged by a cent or two.

A support ticket flagged it. I confirmed it in the logs, rolled the change back within fifteen minutes and told my lead and the support team what customers had seen. Then I wrote a script to find the affected orders, 412 of them, and we refunded the difference that day.

The cause was a test suite that only used single-item orders. I added multi-item cases, and the team now requires them for any change to money calculations.
```

Why it works: the impact is specific, the response is fast and communicated, and the fix targets the process, not a person.

```Sample answer: “Tell me about a time you disagreed with a teammate about a design”
A senior engineer wanted to move our notification code out of the monolith into its own service. I thought it was premature for a team of three.

Before arguing in the pull request, I wrote a one-page comparison: what each option would cost in deploys, on-call and latency, and what would change my mind. When we talked, I learned that his real concern was that notification failures were taking down checkout. I had been underrating that.

We agreed on a smaller step: put notifications behind a queue inside the monolith, so a failure stays isolated. Those incidents stopped. I now ask what problem a proposal is solving before I judge it.
```

Why it works: the disagreement is handled with evidence, the candidate changes their own view, and the outcome is a decision both engineers could support.

## How to prepare

1. **Ask what to expect.** Amazon advises candidates to ask their recruiting contact which subjects and skills will come up.
2. **Practice aloud and timed.** Explain each step as you write, then book a [mock interview](https://jobbie.bot/blog/mock-interview) with another engineer.
3. **Know your resume cold.** Expect detailed questions about any project or technology on your [technical resume](https://jobbie.bot/blog/technical-resume).
4. **Prepare behavioral stories** with the [STAR method](https://jobbie.bot/blog/star-interview-method).

## Frequently asked questions

### What questions are asked in a software engineer interview?

Expect coding problems on arrays, strings, hash maps, trees and graphs, questions on fundamentals such as how a hash table or a database index works, and behavioral questions about past projects, bugs and disagreements. Candidates for mid-level and senior roles should also expect a system design discussion.

### Do entry-level software engineers get system design questions?

Less often. Duke University’s career center describes system design as typically for mid to senior level roles. Entry-level candidates are more likely to be asked to design the classes for a small system, or to talk through a simplified design to show how they think. Ask your recruiter which rounds to expect.

### How do you prepare for a system design interview?

Practice the order of the conversation. For a system you use every day, write down the requirements, a rough scale, the API, the data model and the main components, then name the likely bottleneck and one trade-off. Do it aloud against a clock, and ask another engineer to challenge your choices.

## Sources

- [Amazon: Software Development Interview Topics](https://amazon.jobs/content/en/how-we-hire/interview-prep/software-development-topics): the published topic list, what interviewers look for, practicing outside an IDE and asking the recruiter what to expect.
- [Carnegie Mellon University Career and Professional Development Center: Technical Interviews](https://www.cmu.edu/career/documents/resources-by-college/scs/technical-interview-guide-2022.pdf): the focus on process, what employers expect of candidates, and the warning against bluffing.
- [Yale Office of Career Strategy: Computer Science Technical Interview Preparation Guide](https://ocs.yale.edu/resources/yale-computer-science-technical-interview-preparation-guide/): the coding assessment and the live technical screen.
- [Duke University Career Hub: Technical Interviewing Guide](https://careerhub.students.duke.edu/resources/technical-interviewing-guide/): system design as typically a mid to senior level topic, and behavioral interviews.