← All resources

Resources · Interview primer · Senior

Interview primer,
senior level.

For 5–8 years. Drive open-ended design, show runtime and data-layer depth, an opinion on testing and code quality, performance debugging, security basics, and behavioral stories that prove ownership and cross-team impact. Tick a topic once you can lead the conversation on it.

9Modules

Senior5–8 years

40Questions

↗ Prep improving+1 point for every box you tick

Coverage

Readiness Score

0%

topics prepped

Design & architecture0/5

Language depth0/5

Data at scale0/5

Code quality0/4

Domain & fit0/3

Progress saves automatically in this browser — come back any time and pick up where you left off.

What to prioritize

What senior loops weight most.

They test hardest

Open-ended system design
Depth on your own systems
Debugging a live incident
Ownership & cross-team stories

Table stakes

Testing strategy opinion
Code review judgement
Security basics (OWASP)
A specific "why us"

1System design & architecture

0/5▶

Senior loops weight design and depth heavily. Drive an open-ended design and defend tradeoffs.

Design fluency

Run a senior-level system design end to end: consistency, failure, observability.

Resources — System Design (Senior).

Deep dives on your own architecture: why this DB, this queue, this boundary — and the tradeoff.

Designing Data-Intensive Applications.

Monolith vs services; when NOT to split (Conway's Law).

Fowler — Monolith First.

Caching strategies & where to add them (CDN → HTTP → Redis → query).

AWS — Caching.

Event-driven vs request/response; when async decoupling helps.

Fowler — Event-driven.

2Language & runtime depth

0/5▶

Seniors get probed on what happens under the hood, not just syntax.

Under the hood

Event loop / concurrency model of your runtime (Node event loop, Python GIL, threads vs async).

Node — Event loop.

Memory model & garbage collection at a high level; common leak sources.

MDN — Memory management.

Concurrency primitives: promises/futures, workers, locks; race conditions.

javascript.info — Async/await.

Immutability, pure functions, and why they ease reasoning & testing.

Fowler — Value object.

Dependency management & supply-chain risk (lockfiles, pinning).

npm — package-lock.

3Databases & data at scale

0/5▶

Seniors own data-layer decisions and their failure modes.

Data judgement

Indexing & reading a query plan (EXPLAIN); fixing a slow query.

Use The Index, Luke.

Transactions, ACID, isolation levels & the anomalies they prevent.

PostgreSQL — Isolation.

Replication vs sharding; the N+1 problem; keyset pagination.

Resources — SQL (Senior).

SQL vs NoSQL tradeoffs; choosing a store per access pattern.

DDIA — ch. 3.

Idempotency & exactly-once effects for writes.

Stripe — Idempotency.

4Testing strategy

0/4▶

Seniors are expected to have an opinion on testing and to design for it.

What & how to test

The test pyramid: unit vs integration vs e2e; what belongs where.

Fowler — Test pyramid.

Test doubles: mocks vs stubs vs fakes; when each is appropriate.

Fowler — Mocks aren't stubs.

Writing testable code (DI, pure functions, seams).

Fowler — Dependency Injection.

What to test for a bug fix (a regression test that fails first).

Fowler — Unit test.

5Code quality & review

0/4▶

Seniors are trusted with the codebase — expect questions on readability, review, and tech debt.

Craft

What makes a good code review; giving/receiving feedback.

Google — Code review.

Recognising and paying down tech debt without stalling delivery.

Fowler — Technical debt.

Refactoring safely behind tests; strangler fig for bigger changes.

Naming, small functions, and reducing coupling (SOLID in practice).

Resources — LLD (Senior).

6Performance & debugging

0/4▶

"This endpoint is slow — debug it" is a common senior prompt. The shape is measure first.

Find and fix

Measure first (logs, APM, tracing) → DB? N+1? missing index? → cache → payload → scale out.

Latency numbers.

Frontend performance: code splitting, lazy loading, memoisation, bundle size.

web.dev — Learn Performance.

Profiling: CPU vs memory; flame graphs at a glance.

Chrome DevTools — Performance.

A production incident you owned: reproduce → isolate → fix → prevent.

Google SRE — Incidents.

7Security basics

0/3▶

Seniors are expected to avoid the common vulnerabilities by default.

Don't get owned

OWASP Top 10 by name; injection, broken auth, XSS.

OWASP — Top 10.

Parameterized queries; output encoding/CSP; never trust client input.

OWASP — SQL Injection.

AuthN vs AuthZ; hashing passwords; secrets management.

OWASP — Password storage.

8Leadership & behavioral (senior)

0/5▶

The senior behavioral bar is ownership, mentoring, and cross-team impact — not "I did the task".

Stories that show scope

Leading a project end to end: scoping, breaking down work, unblocking others.

Behavioral guide.

Draft answer

Shape — "I owned [project]: I scoped it into [milestones], split work across [N] people, and unblocked [a dependency/decision]."

Result — a delivery metric + a leadership signal: "shipped in [time], and two engineers grew into owning parts of it." Emphasise decisions you made, not tasks you did.

Mentoring: a concrete example of levelling up a teammate.

Draft answer

Pick one person and one arc: "[Name/role] was struggling with [area]; I [paired / set up a plan / gave stretch work + feedback], and within [time] they [owned X independently]." Concrete beats "I like helping people".

Conflict / disagreement resolved with data and disagree-and-commit.

Behavioral — conflict.

A deadline crunch: how you prioritised and cut scope loudly and early.

Influencing without authority; pushing back on a bad approach.

Behavioral guide.

9Domain & "why us"

0/3▶

Seniors are hired for judgement in a domain — connect your experience to their product concretely.

Make it specific

Research the product & architecture; connect a real constraint you've handled to their domain.

Behavioral — why us.

Have an informed opinion on their tech tradeoffs — not arrogant.

Ask sharp questions about scale, on-call, and how decisions get made.

Questions to ask.

Senior bar = design depth, code judgement, and scope-showing stories · own the outcome, not the task. All links open in a new tab.