Four-month switch plan (Sept–Jan)

artifact

CLI argument parser

artifact

CSV parser (quoted fields, embedded newlines)

artifact

LRU cache with hand-rolled doubly linked list

artifact

Token-bucket rate limiter

artifact

Retry wrapper (exponential backoff + full jitter)

artifact

Connection pool (checkout, checkin, timeout)

artifact

Bounded work queue with backpressure

drill

One primary language (Python), one secondary (Elixir)

drill

Tests you wrote — empty input, capacity boundary, concurrency, timeout

drill

Error handling: timeout, partial read, closed socket, malformed input

drill

Clone a small repo; trace one request path end to end

question

Arrays: two pointers, sliding window, prefix sums, Kadane

question

Hashing: frequency maps, grouping, set membership

question

Strings: parsing, palindromes, anagram patterns

question

Stacks/queues: monotonic stack, min stack, deque sliding window

question

Binary search: answer space, first/last, rotated array

question

Recursion fundamentals

question

Tree traversal: pre/in/post — recursive and iterative

question

BFS and DFS

drill

Pattern recognition over problem count

drill

Re-derive solved problems from scratch

drill

Solve timed; narrate out loud while coding

drill

~40 problems this month, each re-derived at least once

question

fork, exec, wait

question

PIDs, PPIDs, orphans, zombies

question

Process groups and sessions

question

FD table vs open file descriptions vs inodes

question

dup, dup2; inheritance across fork

question

Redirection mechanics

question

/proc/<pid>/status, /fd, /maps, /limits, /stat, /cmdline

question

/proc/meminfo, /proc/loadavg

question

SIGTERM vs SIGKILL vs SIGHUP vs SIGSTOP

question

Handlers; why SIGKILL cannot be caught

question

Graceful shutdown semantics

question

Signal safety

question

Virtual vs resident; RSS vs VSZ

question

Page cache, swap

question

The OOM killer

question

Inodes, hard vs symbolic links, mount points

question

Why df and du disagree

question

Users, groups, mode bits, setuid

question

Shared address space and debugging implications

resource

ps / top / htop — what is running, what is consuming

resource

lsof — what holds this file or port; deleted-but-held files

resource

ss — socket states, listening ports, connection counts

resource

strace — syscalls this process is making

resource

df / du — disk full vs directory bloat

resource

free / vmstat — memory pressure, swapping, run queue

resource

iostat — disk saturation vs latency

resource

journalctl / systemctl — service state, logs, restart loops

resource

grep / awk / sed — log slicing, field extraction

resource

curl — full request control, -w timing, verbose TLS

resource

dig / nslookup — resolution path, TTLs, resolver

resource

tcpdump — what is on the wire

question

Pattern matching, destructuring, pin operator

question

Guards and guard-safe expressions

question

Pipe operator idioms

question

Structs vs maps vs keyword lists

question

Protocols and polymorphism

question

Behaviours and callbacks

question

with expressions and error chaining

question

Comprehensions and :into

question

Streams vs Enum; lazy evaluation

question

Tail call optimisation and recursion

question

Binaries, bitstrings, binary pattern matching

question

Sigils

question

Macros, quote/unquote, AST

artifact

HTTP API with deliberate ID generation strategy

artifact

Postgres schema with unique index

artifact

Redis cache layer

artifact

Config from environment

artifact

Docker Compose: app + Postgres + Redis, healthchecks

artifact

Structured logging with request IDs

artifact

/metrics and /healthz endpoints

artifact

Run as systemd unit on bare Ubuntu

artifact

Wire in your rate limiter from 1.1

artifact

One-page CV (two variants: Elixir-first, AI/backend-first)

artifact

Target list with comp band, JD link, status columns

drill

Reverse-engineer JDs; tally skill frequency (≥60% = priority)

drill

All talent networks in Week 1

drill

All Elixir roles in Week 1

drill

6–10 targeted applications per week

drill

Apply within 5–7 days of posting; set standing alerts

question

Three-way handshake

question

Connection states: LISTEN, ESTABLISHED, TIME_WAIT, CLOSE_WAIT

question

Listen backlog; Nagle, keepalive

question

Ephemeral port exhaustion

question

Routing, MTU, fragmentation

question

Resolution path, resolv.conf, nsswitch.conf

question

Record types; TTL, caching; dig +trace

question

Status codes — especially 499, 502, 503, 504

question

Host header, Content-Length vs chunked

question

HTTP/1.1 HOL blocking vs HTTP/2 multiplexing

question

TLS handshake, cert chains, SNI; curl -v, openssl s_client

question

L4 vs L7; health checks, upstream timeouts

question

X-Forwarded-For; where a 504 is generated

question

Timeouts, retries, idempotency, circuit breakers

question

Rate limiting: token bucket, leaky bucket, sliding window

question

Connection pool sizing; load shedding

drill

tcpdump capture filters

drill

Reading a handshake; retransmits and RSTs

drill

1. Clarify impact — who, what, since when

drill

2. Establish scope — all users or some, one region or all

drill

3. Gather evidence — logs, metrics, traces, reproduction

drill

4. Form hypotheses — plural, ranked by likelihood × cheapness

drill

5. Test hypotheses — cheapest discriminating test first

drill

6. Identify root cause — trigger vs cause

drill

7. Fix — mitigate first, fix properly second

drill

8. Validate — with the same evidence that showed failure

drill

9. Communicate — impact, status, ETA, non-engineer language

drill

10. Prevent recurrence — detection, alerting, guardrail

drill

Write a blameless postmortem

drill

Mid-incident status update

drill

Say "I don't know yet" without losing credibility

drill

API 500s — journalctl, app logs, curl

drill

API 504s — ss, curl -w, upstream logs

drill

Database unavailable — ss, pg_isready, dig

drill

Redis unavailable — redis-cli ping, INFO memory

drill

DNS failure — dig, resolv.conf

drill

CPU spike — top, pidstat

drill

Memory leak — free, vmstat, /proc/<pid>/status

drill

Disk full — df, du, lsof +L1

drill

Pool exhaustion — app metrics, ss, pool config

drill

Replica lag — DB stats, iostat

drill

Queue backlog — broker metrics, consumer logs

drill

Deployment failure — systemctl status, journalctl -u

drill

Auth failure — logs, token inspection, clock check

drill

Third-party failure — curl, status page, retry config

question

CAP vs PACELC

question

Consistency models: linearizable, sequential, causal, eventual

question

Paxos conceptually; Raft — leader election, log replication

question

Quorums, R+W>N, sloppy quorums, hinted handoff

question

Vector clocks, Lamport timestamps, hybrid logical clocks

question

Leader election, split brain, fencing tokens

question

Replication: leader-follower, multi-leader, leaderless

question

Partitioning: range, hash, consistent hashing, rebalancing

question

2PC, 3PC, saga pattern

question

Idempotency; exactly-once vs at-least-once vs at-most-once

question

Outbox pattern, change data capture

question

Backpressure, load shedding, circuit breakers

question

Head-of-line blocking; tail latency p50/p95/p99

question

Little's Law, Amdahl's Law, queueing theory

question

Clock skew; failure detectors, gossip, phi accrual

question

CRDTs: G-counter, PN-counter, OR-set, LWW-register

question

B-tree, hash, GIN, GiST, BRIN — when each applies

question

Partial, expression, covering indexes; column order

question

EXPLAIN ANALYZE — seq vs index vs bitmap scan

question

Join types; statistics and planner errors

question

CTEs, window functions, lateral joins

question

MVCC, tuple visibility, xmin/xmax

question

Isolation levels and anomalies each prevents

question

Row-level locking, FOR UPDATE SKIP LOCKED

question

Advisory locks; deadlock detection

question

Vacuum, autovacuum, bloat, XID wraparound

question

PgBouncer modes; why connections are expensive

question

WAL, checkpoints, replication slots

question

Streaming vs logical replication; replica lag

question

Safe migrations: CONCURRENTLY, backfills, expand/contract

question

Redis: structures, eviction, persistence, cluster

question

DynamoDB: keys, GSI/LSI, hot partitions

question

ElasticSearch: inverted index, shards, relevance

question

Layer model, build cache, image size

question

Multi-stage builds; distroless bases

question

Namespaces and cgroups — what isolates a container

question

Networking modes; volumes vs bind mounts

question

Resource limits; OOM-kill; PID 1 problem

question

Core objects: Pod, Deployment, Service, Ingress, etc.

question

Probes: liveness vs readiness vs startup

question

Requests vs limits; QoS; eviction and OOMKilled

question

Rollouts, rollbacks; Service networking

question

Debugging: CrashLoopBackOff, ImagePullBackOff, Pending, DNS in Pod

question

VPC — subnets, route tables, SG vs NACL

question

IAM — principals, policies, roles, assume-role

question

EC2 — families, EBS types, instance metadata

question

S3 — consistency, storage classes, presigned URLs

question

RDS/Aurora — replicas, lag, failover, PITR

question

DynamoDB — partition key design, hot partitions, GSI cost

question

Lambda — cold starts, concurrency, VPC penalties

question

SQS/SNS/EventBridge/Kinesis — selection, DLQs, FIFO

question

CloudWatch — metrics, logs, alarms, blind spots

question

Terraform — state, modules, drift

question

CI/CD — GitHub Actions, OIDC to AWS

question

Cost reasoning — compute vs storage vs egress, NAT gateway

question

Three signals — strengths and weaknesses

question

Metric types: counter, gauge, histogram, summary

question

Cardinality explosion

question

Prometheus: scrape, PromQL, alerting rules

question

Grafana dashboards; Loki, Tempo, Mimir

question

OpenTelemetry: SDK, collector, semantic conventions

question

Distributed tracing: spans, context propagation, sampling

question

Structured logging, correlation IDs, PII scrubbing

question

RED for services; USE for resources

question

SLI/SLO/SLA; error budgets; burn-rate alerting

question

Alert design: symptom-based; alert fatigue

question

On-call, severity levels, blameless postmortems

question

spawn, link, monitor — differences

question

Message passing, mailboxes, selective receive

question

GenServer: call vs cast vs info, handle_continue

question

Supervisor strategies; DynamicSupervisor

question

Task, Task.Supervisor, Task.async_stream

question

Registry; process naming and discovery

question

ETS: table types, when ETS beats GenServer

question

GenStage: demand and backpressure

question

Flow; Broadway

question

"Let it crash" and error kernel design

question

Node connection, :net_kernel, epmd

question

Distributed Erlang limitations; libcluster, Horde

question

Linked lists: reversal, cycle detection, merge

question

BST properties, LCA, diameter, serialise/deserialise

question

Heaps: top-k, merge k sorted, median of stream

question

Graphs: topo sort, cycle detection, union-find, Dijkstra

question

Intervals: merge, insert, sweep line

question

1D and simple 2D DP: knapsack, LIS, edit distance

question

Matrix: spiral, rotate, islands

question

Tries: prefix search, word break

drill

~40 more problems; cumulative ~80

drill

6–10 targeted applications per week

drill

Complete outstanding talent-network screening tests

drill

Have compensation answer ready before first recruiter call

artifact

Refresh GitHub: URL shortener public with README

artifact

LinkedIn headline and About match CV summary

question

Transformer: attention, multi-head, positional encoding

question

Tokenisation: BPE, SentencePiece, cost implications

question

Context windows; attention cost scaling; context degradation

question

Sampling: temperature, top-k, top-p, repetition penalty

question

Structured output: JSON mode, constrained decoding

question

Function/tool calling protocols

question

Streaming responses and partial parsing

question

Chunking: fixed, recursive, semantic; size vs recall

question

Embedding models, dimensionality, normalisation

question

Vector search: cosine, dot, L2; HNSW, IVF, PQ

question

pgvector: HNSW vs IVFFlat, index parameters

question

Hybrid retrieval: BM25 + dense, reciprocal rank fusion

question

Reranking, cross-encoders

question

Query transformation: HyDE, multi-query, decomposition

question

Metadata filtering; contextual retrieval

question

Parent-document and small-to-big retrieval

question

Graph RAG

question

Citation, grounding, attribution verification

question

Retrieval eval: recall@k, MRR, NDCG

question

When RAG is the wrong answer

question

ReAct loop, plan-and-execute, reflection

question

Tool design: granularity, error surfaces, idempotency

question

Multi-agent: supervisor/worker, handoff, debate

question

MCP — servers, tools, resources

question

Memory: short-term buffer, summarisation, episodic, semantic

question

Context management and compaction

question

Sandboxing and permission boundaries

question

Failure modes: loops, tool thrash, hallucinated arguments

question

Few-shot vs zero-shot; example selection

question

Chain of thought and its limits

question

Prompt caching mechanics and cost impact

question

Prompt injection and defences

question

System prompt design and instruction hierarchy

question

Prompt versioning and diffing

question

Data prep → fine-tune → eval → deploy → monitor → iterate

question

Experiment tracking; dataset versioning

question

CI/CD for models: canary, shadow deploy, rollback

question

Golden datasets; rubric design

question

LLM-as-judge and its failure modes

question

Offline vs online eval vs A/B

question

Regression tracking and eval gating in CI

question

Measuring hallucination and conversational quality

question

LoRA, QLoRA, adapters; when fine-tuning beats prompting

question

Quantisation: GPTQ, AWQ, GGUF; quality-latency tradeoff

question

Serving: vLLM, TGI, batching, KV cache, paged attention

question

GPU fundamentals: VRAM sizing, tensor vs pipeline parallel

question

Model routing and fallback chains

question

Cost modelling per request; token budgeting

question

Drift detection, guardrails, graceful degradation

question

Observability: trace a full turn, log prompts safely

question

Sample rate, bit depth, PCM; codecs Opus, PCMU/PCMA

question

WebRTC: SDP, ICE, STUN/TURN, DTLS-SRTP

question

WebSocket audio transport, chunking, framing

question

VAD: energy-based, WebRTC VAD, Silero; threshold calibration

question

Endpointing: silence thresholds, semantic endpointing, barge-in

question

Non-native speaker cadence; fixed silence thresholds fail

question

ASR: streaming vs batch, interim vs final, word timings

question

Latency budget: capture → VAD → ASR → LLM TTFT → TTS TTFB → playback

question

TTS streaming, sentence-boundary chunking

question

Backpressure; interruption and cancellation mid-generation

artifact

Voice pipeline doc: architecture, VAD calibration, latency numbers, failure modes

drill

1. Requirements — functional, non-functional, out of scope

drill

2. Scale estimation — users → RPS → storage → bandwidth

drill

3. API design — endpoints, idempotency, pagination

drill

4. Data model — access patterns first, schema second

drill

5. High-level architecture — components and request path

drill

6. Deep dive — pick one component, go three levels down

drill

7. Bottlenecks, failure modes, tradeoffs

question

Caching: cache-aside, write-through, invalidation, thundering herd

question

Database selection: relational vs document vs KV vs wide-column

question

Replication: sync vs async; replica lag; failover and split brain

question

Partitioning: hotspots, rebalancing, cross-partition query cost

question

Queues and streams: delivery semantics, DLQs, idempotent consumers

question

Consistency and availability tradeoffs

question

Security in design: authn vs authz, rate limiting, PII

drill

1. URL shortener — you built it, use real numbers

drill

2. Distributed rate limiter

drill

3. Notification / fan-out service

drill

4. Chat or real-time collaboration

drill

5. Newsfeed / timeline

drill

6. Distributed job scheduler

drill

7. Metrics / observability pipeline

drill

8. Voice AI interview platform

drill

9. Multi-tenant SaaS with per-tenant isolation

drill

10. LLM gateway with routing, caching, fallbacks

drill

11. IoT telemetry ingestion

drill

12. DNS resolver or service discovery

question

Resource modelling, status codes, verb idempotency

question

Pagination: offset, cursor, keyset

question

Versioning; error response design (problem+json)

question

GraphQL: schema, N+1 and DataLoader, complexity limits

question

gRPC: protobuf, streaming modes, deadlines

question

WebSockets vs SSE vs long polling

question

Webhooks: signing, retries, idempotency keys

question

API auth: keys, OAuth2, JWT

question

OpenAPI and schema-first development

question

Backward and forward compatibility

question

OAuth 2.0: auth code + PKCE, client credentials, device code

question

OIDC: ID token vs access token, discovery, nonce

question

SAML; SCIM provisioning

question

JWT: signing, alg:none attack, key rotation, JWKS

question

Session management: cookie flags, SameSite

question

MFA: TOTP, WebAuthn/passkeys

question

RBAC vs ABAC vs ReBAC (Zanzibar)

question

SSO, IdP federation, JIT provisioning

question

OWASP Top 10 — exploit and mitigation each

question

Injection, XSS, CSRF, SSRF

question

Deserialisation; supply chain: SBOM, SCA

question

Threat modelling: STRIDE

question

Crypto basics: hashing vs encryption, TLS, mTLS

drill

Re-derive Month 1 problems — delta is the proof

drill

~20 new problems; cumulative ~100–120

drill

Nice-to-know only if time: advanced DP, segment trees

drill

6–10 targeted applications per week

drill

Two mock interviews this month

drill

Interview loops from Month 1–2 applications landing

drill

Start story bank now — rehearsed, not improvised

question

MUST: arrays, strings, hashmaps, two pointers, sliding window, stack, queue, binary search, recursion, tree traversal, BFS/DFS

question

SHOULD: linked lists, BST, heaps, graphs/topo sort, intervals, 1D/2D DP

question

NICE: tries, union-find, advanced DP, Dijkstra

question

SKIP: segment trees, bit tricks, computational geometry, hard DP

drill

Re-derive, do not accumulate

drill

Every problem timed and narrated aloud

drill

Two per day, morning, before anything else

drill

Parse a messy file

drill

Build a small CLI

drill

Wire up an API integration

drill

Implement a rate limiter

drill

Build a minimal retrieval pipeline

drill

Debug a failing test suite you didn't write

drill

Given broken system — narrate investigation using Month 2 catalogue

drill

Integration round: deploy into customer stack under their constraints

artifact

Performance optimisation — query optimisation, Azure migration

artifact

Distributed systems — ex-dns GenServer, Supervisor, GenStage

artifact

Complex integration — wallet/pass, serverless public-sector

artifact

Real-time systems — Phoenix Channels, rate limiting, auth

artifact

Learning fast across stacks — Elixir → Python → Node → AWS

artifact

Product ownership — founding and shipping solo

artifact

AI engineering — voice pipeline with Month 3 numbers

artifact

Debugging and incident response — Month 2 loop

artifact

Scaling with evidence — URL shortener load-test results

artifact

Infrastructure ownership — three-way deployment work

drill

Real technical disagreement and resolution

drill

Real instance of unblocking or teaching someone

drill

Real tight release under pressure

drill

Something you got wrong and what changed

drill

Think out loud without rambling

drill

Clarifying questions that reveal seniority

drill

Handle "I don't know" with credibility

drill

Whiteboard discipline: legible, structured, narrated

drill

Read interviewer hints; pivot without defensiveness

drill

International style: structured answers, visible reasoning

question

Anchoring — who names a number first, and when

question

Global-band vs location-adjusted; raise early

question

Evaluating equity: strike price, preference stack, dilution

question

Contract rate maths: hourly rate for ₹1 Cr target

question

Managing competing timelines without bluffing

question

Walk-away number before the first call

drill

Mix: two DSA, two system design, two behavioural, one practical/debugging

drill

Fix exactly one gap per round — not five, one

drill

Record every one; re-watch is where value is

drill

Last two with someone who will be harsh

drill

Re-derive Month 1 artifacts cold — rate limiter, LRU, pool, retry

drill

Re-diagnose Month 2 failure modes; time yourself

drill

Re-design a Month 3 system; notice the delta

drill

Read every LOG.md entry from Months 1–3

drill

List what you fumbled; group into 2–3 clusters

drill

Attack clusters directly — measured weakness, not guessed

artifact

GitHub — URL shortener with performance report

artifact

Voice pipeline write-up

artifact

Resume rewrite — ownership verbs, measured numbers

artifact

Portfolio page linking artifacts and write-ups

drill

Keep applying — do not stop because interviews started

drill

Re-apply to Month 1 roles that reposted

drill

Follow up on quiet loops after two weeks

drill

Negotiate from multiple offers if timing allows