Skip to content

InfraDrill · for Senior fullstack engineers

Know what you're missing before your Senior fullstack interview

Our Senior fullstack target covers 10 competencies across 5 interview rounds. Below: what each round covers, what is here to practise it, and a check that tells you which of the 10 you are short on — relative to Senior, not as one number.

The readiness check is part of every pass and takes about 20 minutes. It never predicts an offer; it says which competencies are Ready, Borderline or a Gap for this level.

What we check for a Senior fullstack target

The competencies the readiness check measures for this target, in the order the report lists them. “Weighted” means a gap there counts more in the highest-risk verdict — our judgement that it matters most at this level, not a measured weight.

  1. 1.
    System design & trade-offsCoreweighted 1.5× in the check

    A senior design answer is a conversation about trade-offs; every architecture is right for some constraints and wrong for others.

    164 medium and hard questions

  2. A distributed service is several machines pretending to be one; consensus, replication and consistency decide what that pretence costs.

    163 medium and hard questions · 1 coding exercise

  3. Choosing a store, a schema and an isolation level is among the hardest decisions to reverse and deserves reasoning to match.

    234 medium and hard questions

  4. 4.
    Reliability & failure modesCore

    Systems fail partially and at the worst moment; timeouts, retries, shedding and isolation decide whether a fault stays local.

    373 medium and hard questions · 5 coding exercises

  5. 5.

    Identity, least privilege and secrets are design inputs, not a review at the end; this axis tests which boundary each control actually enforces.

    219 medium and hard questions

  6. An API is a promise other teams build on; versioning, idempotency and error semantics are what make it keepable.

    123 medium and hard questions

  7. Given a symptom — a latency spike, a stalled consumer, a pod that will not start — the question is whether you reach the mechanism before reaching for a fix; this axis checks reasoning from symptom to cause, not recall.

    312 medium and hard questions · 11 coding exercises

  8. Rendering and hydration, React's model of state and effects, the browser's main thread and cache, accessibility: this axis tests mechanisms a backend answer does not reach.

    70 medium and hard questions

  9. Managed services trade control for operations; knowing what each one promises, and in which mode, is the competency the vendor cannot sell.

    219 medium and hard questions

  10. Latency and throughput come from the runtime, the allocator and the data path; guessing where is the expensive mistake.

    175 medium and hard questions

Round by round

Practice is arranged by interview round, not by topic. Each round is a view over the same bank and exercises; open one to see its competencies, with the ones the Senior check measures in bold.

  • Coding24 Go exercises · 550 questions

    Write and fix code under time: correctness, edge cases, concurrency, tests. Practised with the runnable exercises.

    Concurrency, Testing & verification, Code quality & design, Algorithms & data structures, Go language & runtime, AI-assisted engineering

    Coding exercises run real tests in the browser. The coding round is practised in Go; a TypeScript runner is planned and not here yet.

  • System design1012 questions · 2 exercises

    Design a system to requirements and defend the trade-offs: storage, messaging, caching, capacity and cost.

    Distributed systems, Data modelling & storage, Caching, Messaging & async integration, API design & contracts, Capacity & scaling, Cost, Cloud architecture, System design & trade-offs, AI agents & tooling

  • Technical deep dive1389 questions · 24 exercises

    How things actually work and why they fail: networking, concurrency, performance, security, and diagnosing a symptom to its mechanism.

    Concurrency, Data modelling & storage, Networking, Security, Performance, Kubernetes & containers, Algorithms & data structures, AI agents & tooling, Frontend engineering, Go language & runtime, Debugging and incident reasoning

  • Operations and reliability1184 questions · 15 exercises

    Running it in production: reliability, observability, Kubernetes, infrastructure as code, incidents and cost.

    Reliability & failure modes, Observability, Capacity & scaling, Cost, Infrastructure as code, Kubernetes & containers, Cloud architecture, Operations & SRE, Debugging and incident reasoning

  • Behavioral and judgment414 questions

    Decisions with facts on the table: trade-offs, influence, incidents and ownership. Not what you would say — what follows from the situation.

    Collaboration & leadership, Technical judgment: decisions and trade-offs

Two questions from the free demo

From the bank, on this target's first axes, not written for this page. A demo quiz opens with these two; the answer, the explanation and the source come when you submit, with no account needed.

System design & trade-offsmedium

A team removes a deprecated int32 legacy_id = 4; field from a protobuf message. Six months later someone adds uint32 tenant_hash = 4;, filled with a 32-bit hash of the tenant's name. Messages travel in protobuf's binary wire format, and old clients, built while legacy_id existed and still logging it from every message they parse, remain in the field. What do they log, and what should have been done when the field was removed?

Distributed systemshard

A checkout service charges cards through a payment API, up to three attempts per charge. About 2% of calls fail at random, independently and briefly; in some, the connection drops after the card is charged, and the retry charges it again. Proposed: replace the retries with a circuit breaker that opens when at least half of the last 20 calls fail, stays open 30 seconds, then lets one trial call through; nothing else retries. Charges accept an idempotency key: a repeated key returns the earlier result instead of a new charge, and only a completed or declined charge records its key, so a call that fails before either can be retried with it. The team wants no duplicates and failures as rare as today. With the API behaving as today, what would the proposal do, and what meets the goal?

Answer them on the demo

Then practise the gaps

A pass starts with the check and its report, and unlocks practising what it finds: the question bank (2058 questions, every answer citing its source), practice by round, fixed packs you can repeat, spaced repetition and the coding exercises. Passes are one-time: a 3-Month Pass for one cycle, a 6-Month Pass for a longer search. Nothing renews.