The path

One ordering, by dependency rather than by date. Each step says what to read, what to drill, and the criterion for moving on — because "I read it" is not a criterion and "I can say it out loud" is.

The whole required path is about 100 minutes of reading. Everything else — the system design manual, the reference card, the 130 problem plans — is consulted, not read through.

How a day works

Three things, in this order, and the whole thing fits in an hour.

python3 harness/drill.py hoje        # today's problems, chosen by spaced repetition
python3 harness/drill.py conceitos   # 10 min of spoken recall, in English

The problems train coding. The concept cards train the two axes the problems do not touch: knowledge under pressure, and speaking technical English without composing sentences from scratch. Skipping the cards is skipping half the score.

Reading is the third thing, and the smallest. One module per step, once. If you find yourself re-reading, that is a signal to run the cards instead — re-reading feels productive and is the weakest study method there is.

Step 0 — Before anything else

Nothing here is optional, and it takes one evening.

• Read the protocol — 8 min — and memorise the seven steps
• Read problem patterns — 7 min
• Run drill.py conceitos -t protocolo and -t padroes until both average 4

Move on when you can recite the seven steps cold, and name a pattern with its justification.

Step 1 — Fundamentals

Read: complexity · Prereqs: none · Cards: 10

The foundation everything else quotes. Short on purpose.

• drill.py hoje for three days
• drill.py conceitos -t complexidade
• The exercise that matters: state the complexity before you code, three times in a row

Move on when you can locate the log in any bound you give.

Step 2 — Recursion and induction

Read: recursion · Prereqs: 01 · Cards: 9

Placed early because trees, backtracking and DP all assume it, and because the induction material changes how you answer "how do you know it's correct?" everywhere else.

• Prove binary search correct, on paper, out loud, in two minutes
• drill.py conceitos -t recursao

Move on when the invariant-plus-termination argument comes without notes.

Step 3 — Hash tables

Read: hash tables · Prereqs: 01 · Cards: 12 · 🔴 gap

The email asks for this one in writing. It is the most likely "write this from scratch" request you will get.

• Implement a hash table with resize, timed, twenty minutes, no reference — repeat on separate days until twenty minutes is comfortable
• drill.py hoje -t hash
• drill.py conceitos -t hash

Move on when you can build it in twenty minutes while narrating, and the tombstone answer is automatic.

Step 4 — Sorting, heaps and binary search

Read: sorting · Prereqs: 01 · Cards: 12

• Write quicksort and merge sort from memory, with the random pivot and the smaller-side recursion
• drill.py hoje -t ordenacao, then -t heap
• drill.py conceitos -t ordenacao

Move on when the binary search template comes out with no off-by-one, and the merge-sort answer takes under thirty seconds.

Step 5 — Trees, BSTs and tries

Read: trees · Prereqs: 01, 09 · Cards: 14 · 🔴 gap

• Write the three iterative traversals from memory
• Implement a trie from scratch
• Write an AVL insert with all four rotations on paper, then check against code/avl.py
• drill.py hoje -t arvores for four days

Move on when iterative inorder comes from memory and you can draw a left-right rotation without hesitating.

Step 6 — Graphs

Read: graphs · Prereqs: 01, 04 · Cards: 11

• Recite the three representations with their trade-offs, in twenty seconds
• Implement union-find with path compression and union by rank
• drill.py hoje -t grafos for four days

Move on when the three-representations answer is fluent and you can write Kahn's algorithm cold.

Step 7 — Shortest paths

Read: Dijkstra and A* · Prereqs: 05 · Cards: 10 · 🔴 A* is the gap

• Implement Dijkstra with lazy deletion from memory
• Solve Shortest Path in Binary Matrix with BFS, then redo it with A* and compare the expansions
• drill.py conceitos -t dijkstra

Move on when you can state the A*-to-Dijkstra relationship and both heuristic properties without pausing.

Step 8 — Dynamic programming and NP-completeness

Read: NP-completeness and DP · Prereqs: 01, 09 · Cards: 11

DP is the topic Google asks most and candidates skip most. It is weighted accordingly in the drill.

• drill.py hoje -t dp for four days
• Say the state and the transition out loud before coding, every time

Move on when you can name an NP-complete problem in disguise and follow it with the constraints question.

Step 9 — Python and discrete maths

Read: Python and discrete maths · Cards: 12 + 10

Two short modules that pay disproportionately: the Python details are what an interviewer probes when they want depth, and discrete maths is asked more at Google than elsewhere.

• Narrate your stdlib choices on the next five drill problems
• Derive the medical-test answer from scratch

Move on when the base-rate answer and the four Python cost traps are reflexive.

✅ Checkpoint: ready for the first round

Only coding and data structures come up in the first round. Everything above is it. Check yourself against all four:

• drill.py stats — no topic with weight ≥ 1.2 averaging below 3.5
• drill.py conceitos — fewer than twenty cards overdue
• /mock-coding returning a Hire verdict on two consecutive sessions
• A hash table from scratch in twenty minutes, narrated

Step 10 — Operating systems and concurrency

Read: concurrency · Cards: 20 · 🔴 largest gap

Second round only, and the email details it more than any other topic.

• drill.py hoje -t concorrencia
• Write a deliberate deadlock, prove it hangs, fix it by lock ordering
• Run code/concorrencia.py and watch the lost updates
• drill.py conceitos -t concorrencia until it averages 4

Move on when the mutex-versus-semaphore and GIL answers are automatic.

Step 11 — System design

Read: the manual, parts 0 to 2 — 20 min · Cards: 16

Parts 3 to 11 are reference. Do not read them through; consult them per case.

• Four timed 60-minute designs in Google Drawings, recorded: URL shortener, rate limiter, LLM Q&A, and the translation pipeline twice
• Listen back to ten minutes of each recording
• drill.py conceitos -t system-design

Move on when you can produce the three estimates and narrate a request end to end without hesitating.

Step 12 — Googleyness and leadership

Read: G&L · Cards: 7

The only step where the work is writing rather than reading.

• Write eight STAR stories in English, with a number in every result
• Write the four follow-up answers under each one
• Run /mock-gl and keep the rewrite it produces

Done when all eight survive the follow-ups without invention.

If the interviews are scheduled sooner than you finish

Compress in this order. Non-negotiable for the first round: steps 0, 1, 3, 4, 5, 6. Can slip: 2, 7, 8, 9 — though step 8 is DP, so slip it last. Only after passing the first round: 10, 11, 12.

And whatever else is cut, keep the daily drill.py conceitos. Ten minutes of spoken recall outperforms an hour of reading, and it is the only thing here that trains you to speak the answers rather than recognise them.

The night before

Read the reference card — two pages, ten minutes. Then the seven steps in the protocol. Then stop, and go to bed.