TARGETS

Tell me about yourself.

Walk me through your most recent project. What did you build, what was your part, and what would you do differently?

Why did you move into software engineering?

What do you know about our company?

Why do you want to work here, and why this role specifically?

Tell me about a time you had to learn a new technology or an unfamiliar codebase quickly. How did you approach it?

Give me an example of a project or initiative you started on your own. What prompted it?

Tell me about a time you were juggling several projects or deadlines at once. How did you prioritize?

Describe a situation where you didn't communicate well enough. What happened, and what did you change?

Tell me about a conflict on your team. How was it resolved, and what would you do differently now?

Tell me about a time you were given an ambiguous or under-specified task. What did you do first?

Describe a project you worked hard on that still didn't get the result you wanted. Why, and what did you learn?

Tell me about a time you had trouble getting others to accept your idea. How did you approach it? Did it work?

Tell me about a time you were responsible for planning a piece of work. Did it go to plan? What did you adjust?

Tell me about a mistake you made at work. How did you handle it, and what did you change?

Tell me about a time you worked with someone who wasn't pulling their weight. Did you talk to them? To your manager?

Describe a time you worked well under pressure. What was going on, and how did you get through it?

Tell me about a time you failed.

Tell me about a time you disagreed with a decision but committed to it anyway.

Tell me about a time you had to deliver bad news — a slipped deadline, a bug in production — to a stakeholder.

Tell me about a time you had to push back on scope or say no. How did you do it?

How do you decide when to ask for help versus keep digging on your own?

Tell me about a time you used an AI tool to move faster. How did you check its output?

Describe how you've worked with people in other time zones or mostly asynchronously. What worked, and what didn't?

What's some critical feedback you've gotten recently, and what did you do with it?

How do you stay current? What do you read, watch, or build?

Where do you want your career to be in five years? What does your ideal role look like?

Give me an example of a time you had to take a creative and unusual approach to solve a problem. How did this idea come to your mind? Why do you think it was unusual?

Give an example of an important project goal you reached and how you achieved it.

Tell me about your experience at your current place of employment.

Do you have any questions for me?

What does `<!DOCTYPE html>` do?

What is semantic HTML, and why does it matter for accessibility, SEO, and maintainability?

What's the difference between `<button>`, `<a>`, and a `<div>` with a click handler? When is each correct?

What are `data-*` attributes good for?

Describe the difference between a cookie, `sessionStorage`, and `localStorage`.

Describe the difference between `<script>`, `<script async>`, `<script defer>`, and `<script type="module">`. Where do scripts and stylesheets go in the document, and why?

What does the viewport meta tag do?

Why would you use `srcset`/`sizes` or `<picture>`? How does the browser decide which image to load?

How do you serve a page in multiple languages, and what do you have to watch out for on multilingual sites?

What makes a form accessible? (labels, required fields, error messages, focus management)

What is ARIA, and when should you *not* use it?

How do you visually hide content but keep it available to screen readers?

How do you make a custom component — a modal, a dropdown, tabs — keyboard-accessible?

What is progressive enhancement? What breaks for your users if your JavaScript fails to load?

What is CSS specificity, and how is it calculated?

Explain the box model. What does `* { box-sizing: border-box; }` do, and why is it the default in most projects?

What's the difference between `static`, `relative`, `absolute`, `fixed`, and `sticky` positioning?

What is the `display` property? What's the difference between `block`, `inline`, and `inline-block`?

When do you reach for Flexbox, and when do you reach for Grid?

Explain `z-index`. How is a stacking context formed, and why does `z-index: 9999` sometimes not work?

What is the cascade? What are cascade layers (`@layer`) for?

What are CSS custom properties, and how do they differ from Sass variables?

Explain pseudo-classes vs pseudo-elements, with examples of each.

`rem` vs `em` vs `%` vs `vh`/`vw` — when do you use each? What does `clamp()` do?

What is mobile-first design, and how do media queries support it?

How is responsive design different from adaptive design?

What are container queries, and how do they differ from media queries?

What does `:has()` let you do that you couldn't before?

What are the tradeoffs of utility-first CSS (Tailwind) vs CSS Modules vs CSS-in-JS vs plain CSS?

How do you load a custom web font without a flash of invisible text? What does `font-display` do?

Why animate with `transform` and `opacity` instead of `top`/`left`/`width`?

What are `prefers-reduced-motion` and `prefers-color-scheme`, and how do you respect them?

Walk me through how you debug a layout bug in DevTools.

What are JavaScript's data types? What's the difference between primitives and reference types?

What's the difference between `var`, `let`, and `const`?

What's the difference between `==` and `===`?

What are the falsy values in JavaScript? What bugs does truthiness cause?

What's the difference between `null`, `undefined`, and undeclared? How do you check for each?

Explain hoisting. How does it differ for `var`, `let`/`const`, function declarations, and function expressions?

What is scope? Explain global, function, block, and lexical scope.

What is a closure? Give a real use case (not just "a counter").

Explain how `this` works. How do `call`, `apply`, and `bind` change it?

How do arrow functions differ from regular functions (`this`, `arguments`, `new`)?

Explain prototypal inheritance and the prototype chain.

What are ES6 classes? How do they differ from constructor functions? What are static members and private fields (`#`)?

What's the difference between a function declaration and a function expression?

What is an IIFE, why was it used, and why do you see it less now?

What is a higher-order function? Name several from the standard library.

`forEach` vs `map` vs `filter` vs `reduce` — when do you use each, and which ones return a new array?

What is destructuring? Give an object example and an array example.

What's the difference between spread and rest syntax?

What do optional chaining (`?.`) and nullish coalescing (`??`) solve? How does `??` differ from `||`?

Mutable vs immutable; shallow vs deep copy. How do you copy an object or array (spread vs `structuredClone`)?

What's the difference between `Map`/`Set` and plain objects/arrays? When would you use `WeakMap`?

What is currying / partial application, and when is it useful?

What are iterators and generators?

Why is extending built-in objects a bad idea? Why should you leave the global scope alone?

What's the difference between CommonJS and ES modules? How do you import and export?

What does `"use strict"` do, and why don't you write it much anymore?

How does garbage collection work at a high level? What causes memory leaks in JavaScript (listeners, timers, closures)?

Make this work: `duplicate([1,2,3,4,5]); // [1,2,3,4,5,1,2,3,4,5]`

FizzBuzz to 100: "fizz" at multiples of 3, "buzz" at multiples of 5, "fizzbuzz" at both.

Reverse a string without `.reverse()`.

Count the frequency of each word in a string and return the top three.

Flatten a nested array. Then do it without `.flat()`.

Remove duplicates from an array. Then from an array of objects, by `id`.

Implement `debounce(fn, ms)`.

Group an array of objects by a key — with `reduce`, then with `Object.groupBy`.

Explain the event loop: call stack, task queue, microtask queue. Why doesn't `setTimeout(fn, 0)` run immediately?

What's the difference between synchronous and asynchronous code? Why does JavaScript need async at all?

What is a callback? What is callback hell, and how did Promises and async/await fix it?

What is a Promise? What states can it be in?

`Promise.all` vs `allSettled` vs `race` vs `any` — when do you use each?

How does async/await work, and how do you handle errors with it?

In what order does this log — synchronous code, a `setTimeout(…, 0)`, and a resolved promise's `.then`? Why?

How do you make an HTTP request with `fetch`? Why doesn't `fetch` reject on a 404?

What is `AbortController`, and when do you use it?

What is the DOM? What's the difference between an attribute and a property?

Explain event bubbling, capturing, and delegation.

`event.preventDefault()` vs `event.stopPropagation()`?

`innerHTML` vs `textContent` — why is `innerHTML` with user input dangerous?

What happens when you type a URL and press Enter? (DNS → TCP/TLS → HTTP → parse → render)

What is the critical rendering path? What's the difference between reflow and repaint?

What is progressive rendering (lazy-loading images, prioritizing above-the-fold content, streaming HTML from the server)? What does each one improve for the user?

What are Core Web Vitals (LCP, INP, CLS), and what improves each one?

Debounce vs throttle — what's the difference, and when do you use each?

What are lazy loading, code splitting, and tree shaking?

What is the same-origin policy? What is CORS, and does the client or the server fix a CORS error?

When would you use WebSockets or server-sent events instead of polling?

What is TypeScript? What does it catch, and what does it *not* catch?

`interface` vs `type` — when do you use each?

What are union and intersection types? What is a discriminated union?

What are generics? Write `first<T>(arr: T[]): T | undefined`.

What is type narrowing? (`typeof`, `in`, `instanceof`, discriminants, type predicates)

What are `any`, `unknown`, and `never`? Why avoid `any`, and what do you use instead?

What are utility types (`Partial`, `Pick`, `Omit`, `Record`, `ReturnType`)?

How do you type a function that takes a callback? A React component's props?

`enum` vs a union of string literals — which do you prefer, and why?

What is structural typing, and how does it differ from nominal typing?

What does `strict: true` turn on, and why does `strictNullChecks` matter?

What happens to types at runtime? Why do you still need runtime validation (Zod) at API boundaries?

What is React? What problem does it solve, and what are the virtual DOM and reconciliation?

What is JSX, and what does it compile to?

What's the difference between state and props?

What is a controlled vs uncontrolled component?

What are the rules of hooks, and why do they exist?

`useState`: what does calling the setter actually do? When do you use the functional update form? Why must state be treated as immutable?

`useEffect`: what does the dependency array control? What is the cleanup function for? What are the common mistakes?

Why does React need `key`s, and why is the array index usually a bad key?

`useRef` — give two different use cases.

`useMemo` and `useCallback` — when do they help, when are they premature, and what does the React Compiler change?

`useReducer` vs `useState` — when would you switch?

What is context? What are its pitfalls?

Local state vs context vs an external store (Zustand/Redux) vs server state (TanStack Query) — how do you decide?

What is "lifting state up"? What is prop drilling, and how do you fix it (composition, context)?

What are two-way data binding and one-way data flow, and how are they different?

How do you fetch data in React? What are the pitfalls (race conditions, waterfalls, Strict Mode double-invoke)?

What are error boundaries?

What is a re-render? What triggers one, and how do you find unnecessary ones?

What is Suspense, and what does it enable?

CSR vs SSR vs SSG vs ISR — what are the tradeoffs? What is hydration?

What are React Server Components, and how do they differ from client components?

What's new in React 19 — Actions, `useActionState`, `useOptimistic`, the `use` hook, form actions?

How do you handle forms in React?

How does client-side routing work (React Router / Next.js App Router)?

How do you test React components? What's the React Testing Library philosophy?

What are some React anti-patterns you've learned to avoid?

What is Node.js? What is it good at, and what is it bad at?

Why is Node "single-threaded," and how does it handle many concurrent requests? (event loop, libuv, thread pool)

What are `package.json` and `package-lock.json`? Dependencies vs devDependencies? What do `^` and `~` mean?

What does `npx` do? What's the difference between `npm install` and `npm ci`?

CommonJS vs ESM in Node — how do you choose, and what breaks when you mix them?

What are streams and buffers? When would you use a stream instead of reading a whole file?

What is `EventEmitter`, and what is event-driven programming?

`setTimeout` vs `setImmediate` vs `process.nextTick`?

What is middleware in Express? How does `next()` work? Write a logging middleware.

How does Express handle errors, including errors thrown in async route handlers?

What is REST? What makes an API RESTful?

Explain the HTTP methods and idempotency: GET, POST, PUT, PATCH, DELETE.

Which status codes do you return for: created, no content, bad input, unauthenticated, forbidden, not found, conflict, server error?

How do you design a good endpoint — naming, versioning, pagination, filtering, sorting?

REST vs GraphQL — when would you choose each?

How do you validate request bodies (Zod/Joi), and why do you never trust the client?

What are environment variables? How do you keep secrets out of the repo and out of the client bundle?

How do you structure a Node project (routes / controllers / services / models)?

What is rate limiting, and why does every public API need it?

What are serverless and edge functions? What are their tradeoffs (cold starts, timeouts, state)?

SQL vs NoSQL — how do you decide?

What are primary keys, foreign keys, and indexes? When does an index hurt?

Explain `INNER JOIN` vs `LEFT JOIN` with an example.

What is normalization? When would you denormalize?

What is a transaction? What does ACID mean?

What are database constraints (unique, not null, check), and why enforce them in the database instead of only in code?

What is an ORM (Prisma, Drizzle, Mongoose)? What are the tradeoffs vs raw SQL?

What is a migration, and why do you need them?

What is the N+1 query problem, and how do you fix it?

Offset vs cursor pagination — what are the tradeoffs?

In MongoDB, when do you embed a document vs reference it?

What is caching (Redis)? What's hard about cache invalidation?

Model users, posts, and comments. Now add likes. Now add followers. (data modeling out loud)

Authentication vs authorization?

Sessions + cookies vs JWTs — how does each work, and what are the tradeoffs?

What is OAuth doing under the hood when you "Sign in with Google"?

How do you store passwords? (salted hashing with bcrypt/argon2 — never encryption)

What do the `HttpOnly`, `Secure`, and `SameSite` cookie flags do?

What is XSS, and how do you prevent it?

What is CSRF, and how do you mitigate it?

What is SQL injection, and how do parameterized queries prevent it?

What is CORS actually protecting? Why is `Access-Control-Allow-Origin: *` a problem with credentials?

What is a Content Security Policy?

Name a few of the OWASP Top 10 and how you'd defend against each.

What must never end up in a Git repo, a log line, or a client bundle?

How do you implement role-based access control in an API? Where do you check it?

What is DNS?

What's in an HTTP request and response? (method, path, headers, body, status)

What is HTTPS/TLS doing? What is a certificate?

What are caching headers (`Cache-Control`, `ETag`), and what is a CDN?

What is a port? What is a reverse proxy (nginx), and why do you put one in front of Node?

What happens between `git push` and production? Explain CI/CD.

What is Docker, and why containerize an app?

Dev vs staging vs production — what's different, and how are secrets and env vars handled per environment?

How would you deploy a full-stack app today (Vercel/Netlify/Render/Railway/Fly vs raw AWS)? What's the PaaS tradeoff?

What is a load balancer? Horizontal vs vertical scaling?

Logs, metrics, traces — what do you check first when production is down?

What is a webhook, and how does it differ from polling?

Unit vs integration vs end-to-end tests — what does each catch, and how many of each do you want?

What tools do you use? (Vitest/Jest, React Testing Library, Playwright/Cypress, Supertest)

What is TDD? When do you practice it?

What are mocks, stubs, and spies? When is heavy mocking a smell?

How do you test async code and API calls?

What makes a test good, and what makes one brittle?

What does code coverage measure, and what does 100% *not* tell you?

Walk me through debugging a bug you can't reproduce.

How do you use DevTools — breakpoints, the Network tab, the Performance tab?

Explain your Git workflow: branch, commit, PR, review, merge.

`merge` vs `rebase` — when do you use each?

How do you resolve a merge conflict?

`fetch` vs `pull`? `reset` vs `revert`? When is rewriting history okay?

What makes a good commit message and a good PR description?

How do you review someone else's code? What do you look for?

How does Agile/Scrum work — standup, sprint planning, retro? What is a ticket's lifecycle?

How do you estimate a task, and what do you do the moment you know you'll miss the estimate?

How do you use AI coding tools day to day? Where do they help, and where do they hurt?

How do you verify AI-generated code before you commit it?

Tell me about a time an AI tool was confidently wrong. How did you catch it?

What must never go into a third-party model — secrets, customer PII, proprietary code — and how do you enforce that on a team?

What is an LLM, in plain terms? What are tokens and a context window, and why do they matter when you paste in a codebase?

What is a hallucination? How do you design a feature so a hallucination can't hurt the user?

What is prompt injection, and why does it matter the moment your app feeds untrusted content (emails, web pages, user input) to a model?

Explain RAG in plain terms. When do you use retrieval vs fine-tuning vs just a better prompt?

What is an embedding? What is a vector database for?

What is tool/function calling? How would you let a model call your API safely — and what's the difference between one completion call and an agent loop?

How do you know a prompt or model change made things better? (evals, golden sets, A/B tests)

How do you control cost and latency in an LLM feature? (caching, smaller models, streaming, trimming context)

Walk me through adding "summarize this support ticket" to a CRUD app — request flow, where the model sits, failure handling, and how you ship it safely.

What is Big O? Give examples of O(1), O(log n), O(n), O(n log n), and O(n²).

What's the difference between time and space complexity? What's the classic tradeoff with hash maps?

What is recursion? What's a base case? Give a JavaScript example. When does it overflow the stack?

What is a data structure? What is an algorithm?

Arrays vs linked lists — tradeoffs, and the complexity of access, insert, and delete.

What is a stack? Where does JavaScript use one?

What is a queue? Where do you see one (event loop, BFS)?

What is a hash table? How does hashing work, and what is a collision?

What is a tree? Binary tree vs binary search tree? What does "balanced" mean, and why does it matter?

What is a heap, and what is it used for (priority queues)?

What is a graph? Directed vs undirected, weighted, adjacency list vs matrix?

BFS vs DFS — how do they work, and when do you use each?

What is a trie, and when would you use one?

What is union-find (disjoint set), and what problem does it solve?

What is a Bloom filter?

What is binary search? What does it require of the input?

Explain bubble sort, insertion sort, merge sort, and quicksort — complexity, and when each is acceptable. What does `Array.prototype.sort` use?

What is a stable sort, and when does stability matter?

What are the two-pointer and sliding-window techniques, and what problems do they solve?

What is memoization? What is dynamic programming, at a high level?

What are polymorphism, encapsulation, and inheritance? Why "composition over inheritance"?

What is functional programming? Pure functions, side effects, immutability — and the tradeoffs vs OOP.

Static vs dynamic typing, strong vs weak — where does JavaScript sit, and where does TypeScript move it?