DSA / coding

75 hours · the longest-lead item in the plan

This is the gate. Not because algorithmic puzzles resemble AI engineering — they don't — but because a coding round eliminates candidates before anyone looks at whether they can build a retrieval system. Applied and service-company work rarely builds interview coding fluency, so for most people arriving from industry this is the binding constraint rather than the AI material.

It's also the one pillar that cannot be crammed. Pattern recognition is built by spaced repetition over months. Everything else here can be compressed into a hard fortnight; this can't. That asymmetry is the entire reason it gets the largest share of a budget aimed at AI roles.

What's actually tested

Two different things, and they need different practice:

1. Classic DSA — arrays, hashing, two pointers, sliding window, binary search, trees, graphs, heaps, intervals, dynamic programming. Standard at big tech regardless of role.
2. Practical coding — increasingly common in AI-native companies. Implement attention in numpy. Write a rate-limited retry wrapper. Parse and batch a stream of requests. Less puzzle, more "can you write correct code under observation."

Most people over-index on (1) and get surprised by (2). Practice both, weighted toward (1) if you're targeting large companies and toward (2) for AI-first startups.

Modules

1 · Pattern acquisition · ~45h

The goal is recognising which of ~15 patterns a problem belongs to within 60 seconds. Not solving faster — classifying faster.

• NeetCode 150 — work through. Pattern-grouped list with video walkthroughs, and a proper superset of the older Blind 75: it adds tries, intervals, bit manipulation, and more 2D DP. Do one pattern at a time, and attempt the problem before watching the video — the video is the answer key, not the lesson.
• Blind 75 — skim the list. Use it only as a compressed re-run before an onsite, or if you have under three weeks total. It hits every major pattern exactly once.

Finish one list before switching

The most common failure here is list-hopping — three sheets at 40% each, no pattern fluency in any. Pick one and complete it.

Done when: given an unseen medium, you can name the pattern and sketch the approach in under two minutes, before writing any code — on 8 out of 10 attempts.

2 · Timed execution · ~20h

Recognising the pattern is not the same skill as producing correct code in 25 minutes while someone watches.

• Timed sets of 2 problems in 45 minutes, no editor autocomplete, talking out loud.
• Record yourself once. It's unpleasant and it's the fastest way to notice you go silent for four minutes at a time, which reads as being stuck even when you aren't.

Done when: two mediums in 45 minutes, working code, narrating throughout — three sessions running.

3 · Practical coding · ~10h

The round AI-first companies increasingly use instead of, or alongside, DSA.

• Implement scaled dot-product attention in numpy from memory. Then multi-head.
• Write a token-bucket rate limiter, then wrap an API call with exponential backoff and jitter.
• Implement a fixed-size KV cache with eviction.
• Stream and batch: consume a generator of requests, batch by size and timeout, flush correctly on shutdown.

These double as LLM internals practice, which is why they earn time here rather than competing for it.

Done when: you can write any of the above in one sitting without a reference, and explain the failure modes of your own implementation.

What I'm skipping

• Hard dynamic programming beyond the common patterns. Poor return per hour; rarely decisive outside of a handful of companies.
• Competitive programming. Codeforces builds a genuinely different skill. It's excellent and it is not what this budget is for.
• Language trivia and puzzle brainteasers. Largely gone from real loops.
• Grinding problem count as a metric. 150 understood beats 500 attempted. Volume is the vanity metric of interview prep.

How I actually run it

Daily, small, relentless. 1–2 problems a day for six months is ~300 problems and roughly 90 hours; four hours every Sunday is the same nominal hours and produces markedly worse recall, because pattern memory consolidates on spacing rather than duration.

Re-solve anything you needed the answer key for, one week later, from scratch. If you can't, you didn't learn it — you read it.