Skip to content

Software engineering: interview questions by round

52 curated questions we wrote as practice material. For each question you get guidance on what a strong answer shows. Use it to structure answers from your own experience, never to memorise someone else's.

Recruiter / HR screen

How answers in this round are assessed
  • Relevance: Answers the actual question and links to the role.
  • Specificity: Concrete facts instead of generic claims.
  • Motivation: Credible, role-specific motivation.
  • Clarity: Short and clear.
  1. Which technologies have you used most in the last two years, and which do you enjoy working with?

    Shows an honest picture of depth versus breadth, with specifics about what you built. Distinguish between what you used daily and what you only touched.

    Skills: TypeScript, Communication

Hiring manager

How answers in this round are assessed
  • Context: Sets up a specific, real situation briefly (who, where, stakes).
  • Own actions: Explains what YOU did and why — decisions, trade-offs.
  • Outcome: States the result, ideally measurable, and what changed.
  • Reflection: Shows learning or what you'd do differently.
  • Clarity: Structured, concise, easy to follow (≈1–3 minutes spoken).
  1. How do you approach estimating work, and what do you do when an estimate turns out wrong?

    mid

    Shows you treat estimates as uncertain, communicate early about changes and learn from misses, rather than defending the number.

    Skills: Agile Delivery, Communication

  2. How do you balance shipping quickly with keeping the codebase healthy?

    Look for pragmatic reasoning about risk, reversibility and context rather than a fixed rule. Give examples of when you chose each way.

    Skills: Code Review, Software Testing

  3. How do you keep your skills current while working on a busy team?

    Shows deliberate, realistic habits and application of learning to actual work.

    Skills: Communication

  4. Tell me about a project you owned technically. What were the main decisions and what would you change now?

    mid

    Shows you can explain trade-offs and your own role. Reflection on what you would do differently signals learning.

    Skills: System Design, Software Architecture

Behavioral

How answers in this round are assessed
  • Context: Sets up a specific, real situation briefly (who, where, stakes).
  • Own actions: Explains what YOU did and why — decisions, trade-offs.
  • Outcome: States the result, ideally measurable, and what changed.
  • Reflection: Shows learning or what you'd do differently.
  • Clarity: Structured, concise, easy to follow (≈1–3 minutes spoken).
  1. Describe a time you pushed back on a technical approach in code review.

    Shows you give specific, respectful feedback with rationale and stay open to the author's context.

    Skills: Code Review, Communication

  2. Tell me about a bug that was difficult to track down. How did you approach it?

    mid

    Shows systematic debugging: forming hypotheses, narrowing the space, using logs and tests, and preventing recurrence.

    Skills: Software Testing, Observability & Monitoring

  3. Tell me about a time you had to deal with a production outage you were partly responsible for.

    mid

    Honest ownership, clear actions during the incident and concrete follow-ups matter more than a flawless record.

    Skills: Incident Management

  4. Tell me about a time you improved the testing or deployment practices of a team.

    Shows identifying a real pain point, small steps, team buy-in and measuring improvement.

    Skills: Software Testing, CI/CD, Change Management

Technical / domain

How answers in this round are assessed
  • Problem understanding: Clarifies the question, assumptions and constraints.
  • Approach: Explains a reasoned approach and alternatives.
  • Trade-offs: Names trade-offs, risks and limits.
  • Experience: Connects to real experience where relevant.
  • Clarity: Structured and precise communication.
  1. Describe how a typical deployment pipeline should work from commit to production.

    Covers build, automated tests, artefact versioning, staged rollout and rollback, with awareness of what each step protects against.

    Skills: CI/CD, Git

  2. Explain how you would design the authentication flow for a web application.

    Look for secure password handling, token or session choice with trade-offs, expiry, and awareness of common attacks such as CSRF and XSS.

    Skills: Security Fundamentals, REST API Design

  3. Explain how you would handle secrets and configuration across development, staging and production environments.

    Shows separation of config and code, least privilege, rotation and not committing secrets, with awareness of what a leak requires.

    Skills: Security Fundamentals, CI/CD

  4. Explain how you would structure a medium-sized Angular or React application.

    Shows reasoning about components, state, data fetching and testing, and avoiding premature abstractions.

    Skills: Angular, React, Software Architecture

  5. Explain the CAP theorem in practical terms and how it affects design choices.

    senior

    Accurate definition with an example of trade-offs during partitions; bonus for noting that it is often oversimplified.

    Skills: System Design

  6. Explain the difference between a process and a thread, and when concurrency can cause bugs.

    mid

    Demonstrates clear fundamentals plus concrete failure modes such as race conditions and deadlocks, and how to avoid them.

    Skills: System Design, Performance Optimization

  7. Explain what Kubernetes does for you and when it is overkill.

    senior

    Shows understanding of scheduling, scaling, self-healing and rollout, balanced with operational complexity for small systems.

    Skills: Kubernetes, Docker & Containers

  8. How does an index speed up a database query, and what are the costs of adding one?

    mid

    Show an accurate mental model of lookup structures, plus write overhead, storage and when an index is not used.

    Skills: SQL, PostgreSQL, Performance Optimization

  9. How do you reason about the security of a third-party dependency before adding it?

    Looks for maintenance, licence, known vulnerabilities, scope of access and the cost of removing it later.

    Skills: Security Fundamentals

  10. How would you find and fix an N+1 query problem?

    Shows you can detect it via logging or profiling, explain why it happens and fix it with joins, batching or eager loading, with trade-offs.

    Skills: SQL, Performance Optimization

  11. How would you investigate a web page that feels slow to users?

    mid

    Shows measurement first: separating network, server and rendering time, picking the biggest bottleneck, and verifying fixes.

    Skills: Performance Optimization, Observability & Monitoring

  12. What are common causes of flaky tests and how would you handle them?

    Cover timing, shared state, external dependencies and ordering, and the cost of ignoring or retrying flaky tests.

    Skills: Software Testing, Test Automation

  13. What are the main security risks in a typical web application, and how do you mitigate them?

    Covers injection, broken authentication and access control, XSS and misconfiguration with practical mitigations, not only names.

    Skills: Security Fundamentals

  14. What are the trade-offs between a relational database and a document store for a new feature?

    Reason from access patterns, consistency needs and team experience instead of ideology. Mention migration and querying costs.

    Skills: SQL, System Design

  15. What do you consider when designing an API that other teams will depend on?

    Covers consistency, backwards compatibility, versioning, error handling and documentation.

    Skills: REST API Design, Technical Writing

  16. What happens, step by step, when you type a URL into a browser and press enter?

    A strong answer covers DNS, TCP/TLS, HTTP, rendering and caching at the depth you actually understand, and says so where you are unsure.

    Skills: HTML & CSS, REST API Design

  17. What is idempotency, and why does it matter when designing APIs?

    Explains safe retries and gives practical mechanisms like idempotency keys and PUT versus POST semantics.

    Skills: REST API Design, System Design

  18. What is the difference between a container and a virtual machine?

    Accurate explanation of kernel sharing and isolation boundaries, with practical consequences for startup, density and security.

    Skills: Docker & Containers, Linux & Shell

  19. What is the difference between unit, integration and end-to-end tests, and how do you decide how many of each you need?

    Reasoning about cost, speed and confidence matters more than naming the pyramid. Mention flaky tests and what each level catches.

    Skills: Software Testing

  20. What makes code easy to change? Give a concrete example from your work.

    Looks for clear boundaries, tests and naming, shown through an actual refactor or design choice rather than slogans.

    Skills: Code Review, Software Architecture

  21. When would you choose TypeScript over plain JavaScript, and when might you not?

    Balanced reasoning about type safety, tooling and team size versus setup cost and false confidence at runtime boundaries.

    Skills: TypeScript, JavaScript

Coding or case study

How answers in this round are assessed
  • Problem understanding: Clarifies the question, assumptions and constraints.
  • Approach: Explains a reasoned approach and alternatives.
  • Trade-offs: Names trade-offs, risks and limits.
  • Experience: Connects to real experience where relevant.
  • Clarity: Structured and precise communication.
  1. Design and implement a simple in-memory rate limiter for an API. What are its limits?

    mid

    Compare fixed window, sliding window and token bucket approaches and discuss concurrency and what changes when scaled across servers.

    Skills: System Design, TypeScript

  2. Given a list of integers, return the first duplicated value or none. Talk through your approach and its complexity.

    junior

    Clarify requirements, propose a simple approach, state time and space complexity and test edge cases. Communication matters as much as the final code.

    Skills: Python, JavaScript

  3. Given a slow SQL query and its execution plan, describe the steps you would take to speed it up.

    mid

    Reads the plan, identifies scans or joins that dominate, considers indexes and query rewriting and verifies with measurements.

    Skills: SQL, PostgreSQL, Performance Optimization

  4. Here is a function with a subtle bug in its pagination logic. Review it and explain what you would change.

    mid

    Shows structured reading, naming of the concrete defect, a proposed test that would have caught it and polite phrasing.

    Skills: Code Review, Software Testing

  5. Implement a function that checks whether the brackets in a string are balanced. What edge cases would you test?

    junior

    Shows a clear data-structure choice, handling of unusual input and a small set of meaningful tests.

    Skills: TypeScript, Software Testing

  6. Implement an LRU cache and explain the data structures behind it.

    senior

    Combines hash map and linked list for constant-time operations; discuss eviction, thread safety and testing.

    Skills: Python, Performance Optimization

  7. Write a function that merges overlapping time intervals. How would you test it?

    mid

    Sort-then-merge with clear reasoning on boundaries; strong answers discuss empty input, touching intervals and complexity.

    Skills: Python, Software Testing

  8. Write a small function to parse a CSV line with quoted fields. What would you do differently for production?

    junior

    Handles quoting and escapes, then recognises when to use a library, plus input validation and test cases.

    Skills: Python, Software Testing

System design

How answers in this round are assessed
  • Problem understanding: Clarifies the question, assumptions and constraints.
  • Approach: Explains a reasoned approach and alternatives.
  • Trade-offs: Names trade-offs, risks and limits.
  • Experience: Connects to real experience where relevant.
  • Clarity: Structured and precise communication.
  1. Design a caching strategy for a read-heavy product catalogue.

    mid

    Discusses cache layers, invalidation, staleness tolerance and stampede protection, with how you would measure benefit.

    Skills: Performance Optimization, System Design

  2. Design a feature flag system. How do you keep it safe and fast?

    senior

    Covers evaluation latency, consistency, targeting, auditability and flag clean-up, with safe defaults when the service is down.

    Skills: System Design, CI/CD

  3. Design a file upload and processing service for large files.

    mid

    Covers direct-to-storage uploads, resumability, validation and virus scanning, asynchronous processing and cleanup.

    Skills: System Design, AWS, Security Fundamentals

  4. Design a job scheduling system that runs recurring tasks reliably across multiple servers.

    senior

    Shows locking or leader election, idempotent jobs, retries, missed run handling and visibility into failures.

    Skills: System Design, Observability & Monitoring

  5. Design a monitoring and alerting setup for a customer-facing API.

    mid

    Starts from user-facing indicators and objectives, avoids noisy alerts and ties alerts to actionable runbooks.

    Skills: Observability & Monitoring, Incident Management

  6. Design a notification system that sends email, push and SMS messages to millions of users.

    senior

    Shows queues, retries, deduplication, user preferences and provider failure handling, along with how you would monitor delivery.

    Skills: System Design, Microservices

  7. Design a URL shortening service. How would you handle scale, collisions and analytics?

    mid

    Start with requirements and estimates, then cover ID generation, storage, caching and failure modes, with explicit trade-offs.

    Skills: System Design, SQL

  8. Design the API and data model for a simple booking system that prevents double bookings.

    mid

    Covers transactions or constraints, concurrency, cancellation and idempotency, and reasons about what the database should guarantee.

    Skills: REST API Design, SQL, System Design

  9. Design the backend for a collaborative document editor. How do you handle concurrent edits?

    senior

    Explain conflict resolution options such as operational transformation or CRDTs and their trade-offs, plus storage and presence.

    Skills: System Design, Software Architecture

  10. How would you design an audit log for a multi-tenant SaaS application?

    senior

    Considers immutability, tenant isolation, retention, privacy obligations and querying needs.

    Skills: System Design, Security Fundamentals, Data Protection & GDPR

  11. We want to move a monolith toward services. How would you decide what to extract first and how?

    senior

    Reasons from seams, change frequency and team structure; includes incremental migration, data ownership and the option of not splitting.

    Skills: Microservices, Software Architecture

Leadership

How answers in this round are assessed
  • Context: Sets up a specific, real situation briefly (who, where, stakes).
  • Own actions: Explains what YOU did and why — decisions, trade-offs.
  • Outcome: States the result, ideally measurable, and what changed.
  • Reflection: Shows learning or what you'd do differently.
  • Clarity: Structured, concise, easy to follow (≈1–3 minutes spoken).
  1. As a tech lead, how do you make architectural decisions with a team and make sure they stick?

    lead

    Shows collaborative decision-making, written decision records, dissent handling and revisiting decisions when facts change.

    Skills: Software Architecture, Technical Writing

Panel

How answers in this round are assessed
  • Context: Sets up a specific, real situation briefly (who, where, stakes).
  • Own actions: Explains what YOU did and why — decisions, trade-offs.
  • Outcome: States the result, ideally measurable, and what changed.
  • Reflection: Shows learning or what you'd do differently.
  • Clarity: Structured, concise, easy to follow (≈1–3 minutes spoken).
  1. Walk the panel through a technical design you are proud of, then respond to their challenges.

    senior

    Presents clearly and receives challenge without defensiveness, acknowledging weaknesses and trade-offs honestly.

    Skills: System Design, Communication

Final

How answers in this round are assessed
  • Relevance: Answers the actual question and links to the role.
  • Specificity: Concrete facts instead of generic claims.
  • Motivation: Credible, role-specific motivation.
  • Clarity: Short and clear.
  1. What engineering practices do you consider non-negotiable on a team, and which are negotiable?

    senior

    Shows reasoned priorities with context awareness instead of dogma.

    Skills: Software Testing, Code Review, CI/CD

Practise these with your own stories and get structured feedback in a free workspace.

Create free account