Senior Rust Interview Preparation Framework

This document defines the learning system for preparing for a Senior Rust interview in a short amount of time.

The goal is not to learn Rust academically from top to bottom. The goal is to maximize interview coverage in the shortest realistic time, understand Rust well enough to reason instead of memorizing definitions, identify weak areas quickly, and avoid burnout.

The core strategy is:

Breadth first, identify weaknesses, then deepen selectively.

Preparation must optimize for interview readiness, not completeness.

Learning Philosophy

Passive consumption must not be the primary learning format.

Avoid:

watching many hours of Rust videos without active testing;
reading documentation linearly for completion;
creating hundreds of flashcards before understanding a topic;
measuring progress by hours spent.

Use this loop instead:

Question -> Answer -> Challenge -> Gap -> Learn -> Explain -> Code -> Re-test -> Card

Target learning balance:

60% active recall, reasoning, explanation, and code;
25% gap-focused learning;
15% passive reading or watching.

Content is a tool for closing demonstrated gaps, not the goal itself.

Do not think:

Today I need to watch three hours of Rust content.

Think:

Today I need to move Ownership and Borrowing from L0 to L1, or from L1 to L2.

Knowledge Levels

Use capability-based levels instead of subjective labels such as beginner, intermediate, or advanced.

L0 - Discovery / Unknown

The topic has not been systematically studied or tested.

At L0, first create a compact topic map containing:

main concepts;
important subtopics;
common interview questions;
dependencies on other topics.

Do not go deep at this stage.

L1 - Explain

Definition:

I can explain the core mental model of the topic without notes.

L1 measures conceptual fluency. For a topic at L1, the candidate should be able to:

explain the main concepts in their own words;
answer basic interview questions in 30-90 seconds;
explain why the feature exists;
distinguish it from adjacent concepts;
avoid major factual errors.

L1 does not require deep compiler or implementation knowledge.

Typical completion criteria:

core material has been studied;
main concepts can be explained without notes;
approximately 70-80% of basic conceptual questions can be answered;
the candidate can present a coherent mental model.

For Ownership and Borrowing, L1 includes answering:

What is ownership?
Why does Rust have ownership?
What is a move?
What happens when assigning one String to another?
Why are integers often copied instead?
What is the difference between Copy and Clone?
What is borrowing?
What is the difference between &T and &mut T?
Why can multiple shared references exist while a mutable reference is exclusive?
When does a borrow end?
What is RAII?
When does Drop run?

L1 should normally be reached quickly. Do not optimize obscure details at this stage.

L2 - Apply

Definition:

I can predict what Rust will do and reason about code.

L2 measures applied understanding. For a topic at L2, the candidate should be able to:

read unfamiliar Rust code;
predict whether it compiles;
explain compiler errors;
explain ownership, lifetime, or type state;
fix code correctly;
avoid using clone blindly;
explain why a fix is sound;
choose between alternative designs;
discuss practical trade-offs.

Typical L2 exercises include:

determine whether code compiles;
explain why it compiles or fails;
predict output;
track ownership after moves;
determine borrow duration;
reason about lifetimes;
reason about Send and Sync;
reason about async behavior;
evaluate API design;
fix code without unnecessary allocation or cloning.

Typical completion criteria:

L1 has been passed;
code reasoning success is approximately 80% or higher;
common compiler errors can be diagnosed;
fixes can be justified;
the topic can be applied to realistic engineering examples.

L2 is the broad target for Senior Rust interview coverage. A genuine L2 across the main Rust map should cover approximately 70-85% of normal Rust-specific Senior interview questions, assuming the interviewer is not intentionally focusing on obscure compiler internals.

L3 - Defend

Definition:

I can withstand multiple Senior-level follow-up questions.

L3 is deeper than remembering or applying a concept. At L3, the candidate should be able to:

answer four or five sequential follow-ups;
explain why Rust is designed this way;
discuss invariants;
compare alternatives;
reason about trade-offs;
connect the topic to adjacent concepts;
handle edge cases;
discuss runtime or compiler implications.

Example starting question:

Why is &mut T exclusive?

Possible follow-ups:

Is &mut really about mutation?
Can mutation happen through &T?
What is UnsafeCell?
Why does aliasing matter to optimization?
Can raw pointers alias?
What is the safety invariant?

Surviving this chain demonstrates L3. L3 is not required for every topic; it is reserved for interview hotspots.

L4 - Internals / Expert

Definition:

I understand the compiler, language model, or implementation details behind the topic.

Examples include:

MIR;
borrow-checker implementation concepts;
drop checking;
variance proofs;
Stacked Borrows or Tree Borrows;
detailed executor and runtime internals;
unsafe memory-model details;
compiler optimization implications.

L4 is optional and generally should not be a primary target during short-term Senior interview preparation.

Target Depth Profile

Do not make every topic L3.

The primary target is:

All important topics at L2 or higher.

Then deepen interview hotspots to L3. Rare or low-return topics can remain at L1.

Topic	Target
Ownership and Borrowing	L3
Lifetimes	L2/L3
Traits and Generics	L2/L3
Memory	L2
Smart pointers	L2/L3
Interior mutability	L2/L3
`Send` and `Sync`	L3
Concurrency	L3
Atomics	L2
Async and `Future`	L3
`Pin`	L2/L3
Tokio	L3
Unsafe Rust	L2
Performance	L2/L3
Macros	L1
Cargo	L1/L2
Patterns	L1/L2
Rare type-system topics	L1

Uniform depth is explicitly not a goal.

Time Expectations

These estimates assume real Rust experience with fragmented or non-systematic knowledge.

L1 Across the Main Rust Map

Aggressive: 4-6 days at 5-7 hours per day.
Realistic intensive: 7-10 days at 3-5 hours per day.
Comfortable: 2-3 weeks at 1.5-3 hours per day.

Target approximately one week for broad L1 coverage of the main interview map. L1 means approximately 70-80% confidence, not perfection.

L2 Across Key Rust Topics

After L1:

Aggressive: another 7-10 days.
Realistic: 2-3 weeks.
Comfortable: 3-5 weeks.

Do not pursue L2 for every obscure topic. Prefer:

L1 everywhere -> L2 for core topics -> L3 for interview hotspots.

Progress Tracking

Do not track time spent as the primary signal.

Avoid:

Studied Ownership for four hours.

Track capability instead:

Ownership L2 passed, L3 partial.

Example topic overview:

Topic	L1 Explain	L2 Apply	L3 Defend	Review
Ownership	Pass	Pass	Partial	Aug 12
Lifetimes	Pass	Partial	Not started	Aug 12
Traits	Pass	Partial	Not started	Aug 13
`Send`/`Sync`	Partial	Not started	Not started	-
`Future`	Not started	Not started	Not started	-
Tokio	Not started	Not started	Not started	-

Track weak subtopics within each topic as well.

Example for Ownership and Borrowing:

Subtopic	Level
Ownership rules	L3
Moves	L3
`Copy` and `Clone`	L2
Borrowing	L3
`&T` and `&mut T`	L2
Reborrowing	L1
Partial moves	L2
NLL	L1
`Drop` and RAII	L2
Aliasing	L1

The purpose is to make gaps visible and actionable.

Topic Session Workflow

Use the following phases for one topic.

Phase 1 - Map

Time box: 5-10 minutes.

Build a compact map of the topic. For Ownership and Borrowing, this might include:

ownership rules;
moves;
Copy;
Clone;
borrowing;
&T;
&mut T;
aliasing;
reborrowing;
partial moves;
NLL;
Drop;
RAII;
common compiler errors.

Do not deep-dive during this phase.

Phase 2 - Core Learning

Typical time box: 30-45 minutes for a normal topic.

Use:

The Rust Book;
The Rust Reference only when needed;
concise explanations;
targeted external content.

After each small section, close the source and explain the material from memory.

Avoid large notes. Record only compact mental models, for example:

Ownership:

every value has an owner;
ownership can move;
when the owner is dropped, the owned value is dropped.

Move:

transfers ownership;
makes the source unusable;
does not make the source unusable for Copy types because assignment copies the value instead.

Borrow:

provides temporary access without transferring ownership.

Phase 3 - L1 Test

Ask 10-15 conceptual interview questions. Answer without notes. Each answer should normally take 30-90 seconds.

Mark gaps immediately.

Phase 4 - Fix Gaps

Study only the demonstrated gaps. Do not reread the entire topic.

Phase 5 - L2 Code Drill

Use 10-20 focused snippets. For each snippet, ask:

Does it compile?
Why or why not?
What exactly is borrowed or moved?
When does the borrow end?
What does the compiler prevent?
How should the code be fixed?
Can it be fixed without clone?
Why is the fix sound?

Phase 6 - L3 Interview Drill

Simulate interviewer follow-ups. Start with a normal question, then repeatedly ask:

Why?
What is the trade-off?
Why not use the alternative?
What happens internally?
What edge case breaks this model?
How does this interact with another concept?

Target four or five chained follow-ups.

Phase 7 - Close and Retain

Record only the outcome:

text

Topic status:
- L1 PASS
- L2 PASS 14/17
- L3 PARTIAL 5/9

Weak:
- reborrowing
- aliasing
- relationship to UnsafeCell

Review:
- tomorrow
- +3 days
- +7 days

Create flashcards only from actual mistakes.

Flashcard Philosophy

Flashcards are secondary. Do not use them as a substitute for understanding.

Avoid shallow definition cards such as:

text

Q: What is Send?
A: A type that can move between threads.

Prefer reasoning cards:

text

Q:
Why is Rc<T> not Send while Arc<T> can be?

Expected checklist:
- reference-count mutation;
- Rc uses a non-atomic reference count;
- cross-thread use could create a data race;
- Arc uses atomic reference counting;
- T must still satisfy the required Send/Sync bounds.

Another example:

text

Q:
Explain Pin to a Senior engineer.

Expected checklist:
- address-sensitive values;
- self-referential structures;
- moving may invalidate internal references;
- Pin<P>;
- Unpin;
- unsafe contract;
- Future::poll.

Generate flashcards primarily from mistakes made during testing.

Cold Retesting

Do not trust understanding measured immediately after studying.

Retest after:

one day;
three days;
seven days.

For example, ask again:

Explain why mutable references are exclusive.

If the question can be answered cold without warming up, the knowledge is becoming stable.

Main Rust Interview Topic Map

A. Rust Core

1. Ownership and Borrowing

ownership rules;
move semantics;
Copy;
Clone;
borrowing;
&T and &mut T;
aliasing and exclusivity;
reborrowing;
NLL;
partial moves;
destructuring and ownership;
borrowing independent fields;
temporaries;
Drop;
drop order;
RAII;
std::mem basics.

Priority: 10/10.

2. Lifetimes

why lifetimes exist;
lifetime annotations;
lifetime elision;
input and output lifetimes;
structs with references;
methods with lifetimes;
'static;
T: 'a;
&'a T;
multiple lifetimes;
lifetime subtyping;
variance;
covariance;
contravariance;
invariance;
&mut variance;
HRTB and for<'a>;
generic lifetime bounds;
reborrowing;
NLL;
drop checking basics;
relationship to PhantomData.

Priority: 10/10.

3. Type System

primitive types;
structs;
enums;
tuples;
arrays;
slices;
str versus String;
newtypes;
type aliases;
never type !;
zero-sized types;
Sized;
?Sized;
dynamically sized types;
coercions;
deref coercion;
unsizing;
type inference;
turbofish;
associated types;
GATs;
impl Trait.

Priority: 8/10.

4. Traits and Generics

traits;
generic functions and types;
trait bounds;
where clauses;
blanket implementations;
coherence;
orphan rules;
associated types;
associated constants;
default methods;
supertraits;
marker traits;
impl Trait;
dyn Trait;
static dispatch;
dynamic dispatch;
monomorphization;
dyn compatibility and object safety;
vtables;
extension traits;
From and Into;
TryFrom and TryInto;
AsRef;
Borrow;
Deref and DerefMut;
Default;
Iterator;
IntoIterator;
FromIterator;
auto traits.

Priority: 10/10.

5. Closures

capture semantics;
immutable borrow capture;
mutable borrow capture;
move capture;
move closures;
Fn;
FnMut;
FnOnce;
closure trait hierarchy;
closures versus function pointers;
returning closures;
async closures conceptually.

Priority: 8/10.

6. Iterators

Iterator;
IntoIterator;
iter, iter_mut, and into_iter;
lazy evaluation;
adapters;
consumers;
map, filter, and fold;
collect;
FromIterator;
custom iterators;
ownership implications;
zero-cost abstraction.

Priority: 7/10.

7. Error Handling

Option;
Result;
?;
error propagation;
custom error types;
std::error::Error;
source chains;
Box<dyn Error>;
anyhow;
thiserror;
panic;
unwind;
abort;
catch_unwind;
panic safety;
poisoning.

Priority: 7/10.

8. Pattern Matching

match;
exhaustive matching;
if let;
let else;
destructuring;
guards;
@;
_;
ranges;
matches!;
ownership inside patterns.

Priority: 6/10.

9. Collections

Vec;
VecDeque;
HashMap;
HashSet;
BTreeMap;
BinaryHeap;
slices;
strings;
capacity;
allocations;
Entry API;
complexity;
HashMap versus BTreeMap trade-offs.

Priority: 7/10.

B. Memory

10. Memory Representation

stack versus heap;
value layout;
alignment;
padding;
size_of;
references;
raw pointers;
fat pointers;
slice representation;
str representation;
trait object representation;
enum layout;
discriminants;
niche optimization;
Option<&T>;
Option<NonNull<T>>;
zero-sized types;
repr(Rust);
repr(C);
repr(transparent);
ABI basics;
endianness basics.

Priority: 8/10.

11. Smart Pointers

Box;
Rc;
Arc;
Weak;
reference counting;
cycles;
Cow;
Pin;
NonNull;
ManuallyDrop;
MaybeUninit.

Priority: 9/10.

12. Interior Mutability

interior mutability concept;
Cell;
RefCell;
runtime borrow checking;
UnsafeCell;
why UnsafeCell exists;
Mutex;
RwLock;
atomics;
Rc<RefCell<T>>;
panic scenarios;
choosing the right primitive.

Priority: 9/10.

13. Unsafe Rust

what unsafe actually means;
unsafe operations and unsafe superpowers;
raw pointers;
unsafe functions;
mutable statics;
unsafe traits;
unions;
soundness;
undefined behavior;
aliasing;
pointer validity;
initialization;
alignment;
UnsafeCell;
MaybeUninit;
NonNull;
safe abstractions over unsafe code;
FFI basics.

Priority: 9/10.

C. Concurrency

14. Threads

std::thread;
spawn;
join;
scoped threads;
ownership across threads;
shared state.

Priority: 9/10.

15. `Send` and `Sync`

This topic requires deep understanding:

meaning of Send;
meaning of Sync;
relationship between them;
auto traits;
why Rc is not Send;
why RefCell is not Sync;
when Arc<T> is Send or Sync;
unsafe impl Send and unsafe impl Sync.

Priority: 10/10.

16. Synchronization

Mutex;
RwLock;
Condvar;
channels;
message passing;
shared memory;
deadlocks;
lock ordering;
contention;
poisoning;
starvation;
parking.

Priority: 10/10.

17. Atomics and Memory Model

AtomicBool, AtomicUsize, and other atomic types;
load and store;
fetch operations;
compare_exchange;
atomicity;
visibility;
reordering;
Relaxed;
Acquire;
Release;
AcqRel;
SeqCst;
happens-before;
synchronization;
lock-free progress;
wait-free progress;
ABA basics;
false sharing;
cache coherence.

Priority: 9-10/10 for systems and low-latency roles.

D. Async

18. Async and `Future`

async fn;
async blocks;
Future;
lazy futures;
Future::poll;
Poll::Ready;
Poll::Pending;
Context;
Waker;
executors;
reactors;
state-machine transformation;
.await;
suspension points;
cancellation;
cancellation safety;
async streams;
Send futures;
borrowing across .await.

Key question:

What actually happens when an async function reaches .await?

Priority: 10/10.

19. `Pin` and `Unpin`

why Pin exists;
address-sensitive values;
self-referential types;
Pin<P>;
guarantees;
Unpin;
why most types are Unpin;
projection;
relationship to Future;
why Future::poll takes Pin<&mut Self>.

Priority: 8/10.

20. Tokio

Runtime:

executor;
scheduler;
tasks;
worker threads;
work stealing;
current-thread runtime;
multi-thread runtime.

I/O:

asynchronous network I/O;
readiness;
reactor;
epoll, kqueue, and io_uring conceptually.

Tasks:

tokio::spawn;
JoinHandle;
spawn_blocking;
task cancellation;
Send + 'static;
blocking versus async work.

Synchronization:

Tokio Mutex;
standard-library Mutex versus Tokio Mutex;
mpsc;
oneshot;
broadcast;
watch;
Semaphore;
Notify.

Runtime behavior:

cooperative scheduling;
yielding;
starvation;
blocking the executor.

Priority: 10/10.

E. Systems

21. Performance

allocations;
stack versus heap;
copying;
cache locality;
cache lines;
false sharing;
branch prediction;
virtual dispatch;
monomorphization;
inlining;
SIMD basics;
bounds checks;
iterator optimization;
zero-copy designs;
arenas;
memory pools;
profiling;
benchmarking;
flamegraphs;
LTO;
PGO conceptually.

Priority: 9/10.

22. OS and Systems Fundamentals

Memory:

virtual memory;
pages;
page faults;
stack;
heap;
malloc;
mmap;
fragmentation.

Processes and threads:

processes;
threads;
context switches;
scheduling;
system calls.

I/O:

blocking and non-blocking I/O;
readiness versus completion;
epoll;
kqueue;
io_uring;
sockets;
file descriptors.

Priority: 8-10/10 depending on the role.

23. Networking

TCP;
UDP;
handshake;
packet loss;
retransmission;
flow control;
congestion control;
Nagle's algorithm;
TCP_NODELAY;
keepalive;
sockets;
buffers;
backpressure;
HTTP basics;
WebSockets;
TLS basics;
serialization;
latency implications.

Priority: 10/10 for low-latency, backend, and trading roles.

F. Engineering

24. Cargo and Modules

packages;
crates;
modules;
visibility;
pub;
pub(crate);
use and imports;
workspaces;
features;
conditional compilation;
build scripts;
dependency types;
Cargo profiles;
release builds;
LTO;
feature unification basics.

Priority: 5/10.

25. Testing

unit tests;
integration tests;
documentation tests;
property testing;
fuzzing;
benchmarking;
Criterion;
Loom conceptually;
deterministic testing.

Priority: 5/10.

26. Macros

macro_rules!;
matching;
repetition;
hygiene;
procedural macros;
derive macros;
attribute macros;
function-like macros;
TokenStream.

Priority: 4/10.

27. Architecture and Senior Engineering

concurrent system design;
shared state versus message passing;
backpressure;
bounded versus unbounded queues;
graceful shutdown;
cancellation;
retries;
idempotency;
batching;
rate limiting;
load shedding;
resource ownership;
observability;
fault isolation;
API design;
library design;
abstraction boundaries.

This is not strictly Rust-specific, but it is critical for Senior interviews.

Recommended Study Order

Do not necessarily follow the numeric topic order. Prefer this progression:

text

Ownership and Borrowing
-> Lifetimes
-> Traits and Generics
-> Smart pointers
-> Interior mutability
-> Send and Sync
-> Threads and Synchronization
-> Async and Future
-> Tokio
-> Pin
-> Atomics
-> Unsafe Rust
-> Memory layout
-> Performance
-> OS and Networking

Insert lower-priority topics around this path where useful.

Interview Coverage Goal

Target:

L1 across the entire relevant Rust map.
L2 across core Rust topics.
L3 for interview hotspots.

Do not attempt L3 everywhere.

Likely hotspots for Senior Rust, backend, and systems interviews:

Ownership and Borrowing;
Lifetimes;
Traits and Generics;
Send and Sync;
Concurrency;
Async and Future;
Tokio;
memory and performance.

A genuine L2 across the main Rust map should cover approximately 70-85% of normal Rust-specific Senior interview questions. The remainder will often consist of:

obscure language corners;
compiler internals;
advanced unsafe code;
advanced variance and drop checking;
niche library knowledge.

These areas should not be optimized first.

Definition of Interview-Ready L2

A topic is not finished merely because the candidate can solve isolated snippets.

For Interview-Ready L2, the candidate must be able to:

Explain the concept.
Solve related code problems.
Handle two or three follow-up questions.
Explain at least one realistic engineering trade-off.

For Arc<Mutex<T>>, this means being able to:

explain what Arc provides;
explain what Mutex provides;
explain the relevant Send and Sync requirements;
reason about a code snippet;
discuss contention;
explain why holding a lock across .await can be problematic;
compare shared-state designs with message passing.

Anti-Patterns

Avoid:

reading too much before testing;
watching long videos passively;
trying to learn every corner of Rust;
spending a full day perfecting one topic;
measuring progress by hours;
making hundreds of generic flashcards;
memorizing answers verbatim;
cloning values randomly to satisfy the borrow checker;
moving into compiler internals before applied understanding is solid.

Codex Collaboration Contract

When Codex assists with this preparation, it should:

Maintain the L0-L4 capability model.
Create a compact topic map before teaching a topic.
Help reach L1 quickly.
Test actively instead of over-explaining.
Generate conceptual interview questions.
Generate compiler and code-reasoning exercises.
Ask chained Senior follow-up questions for L3.
Track weak subtopics.
Recommend targeted reading only for demonstrated gaps.
Create flashcards only from mistakes.
Cold-retest old topics periodically.
Optimize for interview return on investment and short-term retention.
Prevent excessive time investment in low-priority internals.
Prefer practical reasoning and mental models over memorized definitions.
Clearly distinguish L1 Explain, L2 Apply, L3 Defend, and L4 Internals.

The overall objective is:

Build broad Senior Rust interview readiness quickly, then deepen only the areas where deeper knowledge materially improves interview performance.

Senior Rust Interview Preparation Framework ​

Learning Philosophy ​

Knowledge Levels ​

L0 - Discovery / Unknown ​

L1 - Explain ​

L2 - Apply ​

L3 - Defend ​

L4 - Internals / Expert ​

Target Depth Profile ​

Time Expectations ​

L1 Across the Main Rust Map ​

L2 Across Key Rust Topics ​

Progress Tracking ​

Topic Session Workflow ​

Phase 1 - Map ​

Phase 2 - Core Learning ​

Phase 3 - L1 Test ​

Phase 4 - Fix Gaps ​

Phase 5 - L2 Code Drill ​

Phase 6 - L3 Interview Drill ​

Phase 7 - Close and Retain ​

Flashcard Philosophy ​

Cold Retesting ​

Main Rust Interview Topic Map ​

A. Rust Core ​

1. Ownership and Borrowing ​

2. Lifetimes ​

3. Type System ​

4. Traits and Generics ​

5. Closures ​

6. Iterators ​

7. Error Handling ​

8. Pattern Matching ​

9. Collections ​

B. Memory ​

10. Memory Representation ​

11. Smart Pointers ​

12. Interior Mutability ​

13. Unsafe Rust ​

C. Concurrency ​

14. Threads ​

15. Send and Sync ​

16. Synchronization ​

17. Atomics and Memory Model ​

D. Async ​

18. Async and Future ​

19. Pin and Unpin ​

20. Tokio ​

E. Systems ​

21. Performance ​

22. OS and Systems Fundamentals ​

23. Networking ​

F. Engineering ​

24. Cargo and Modules ​

25. Testing ​

26. Macros ​

27. Architecture and Senior Engineering ​

Recommended Study Order ​

Interview Coverage Goal ​

Definition of Interview-Ready L2 ​

Anti-Patterns ​

Codex Collaboration Contract ​

Senior Rust Interview Preparation Framework

Learning Philosophy

Knowledge Levels

L0 - Discovery / Unknown

L1 - Explain

L2 - Apply

L3 - Defend

L4 - Internals / Expert

Target Depth Profile

Time Expectations

L1 Across the Main Rust Map

L2 Across Key Rust Topics

Progress Tracking

Topic Session Workflow

Phase 1 - Map

Phase 2 - Core Learning

Phase 3 - L1 Test

Phase 4 - Fix Gaps

Phase 5 - L2 Code Drill

Phase 6 - L3 Interview Drill

Phase 7 - Close and Retain

Flashcard Philosophy

Cold Retesting

Main Rust Interview Topic Map

A. Rust Core

1. Ownership and Borrowing

2. Lifetimes

3. Type System

4. Traits and Generics

5. Closures

6. Iterators

7. Error Handling

8. Pattern Matching

9. Collections

B. Memory

10. Memory Representation

11. Smart Pointers

12. Interior Mutability

13. Unsafe Rust

C. Concurrency

14. Threads

15. `Send` and `Sync`

16. Synchronization

17. Atomics and Memory Model

D. Async

18. Async and `Future`

19. `Pin` and `Unpin`

20. Tokio

E. Systems

21. Performance

22. OS and Systems Fundamentals

23. Networking

F. Engineering

24. Cargo and Modules

25. Testing

26. Macros

27. Architecture and Senior Engineering

Recommended Study Order

Interview Coverage Goal

Definition of Interview-Ready L2

Anti-Patterns

Codex Collaboration Contract