305 practice briefs

Build something you can check

Choose a mechanism, attempt the task, and compare what you made with the expected evidence. Hints stay separate from the prompt so you can try it first.

Search & IR

Build a search tokenizer
Build an inverted index
Calculate a TF-IDF score by hand
Calculate a BM25 score by hand
Implement a BM25 ranker
Compute precision and recall by hand
Build a search eval harness
Implement reciprocal rank fusion
Cross-encoder rerank top-k
Spell-correct a search query
Browse vs search metrics
Skip documents that cannot reach the top k
NDCG@k
Debias clicks by inverse propensity

Mathematics

Compute a dot product and angle
Multiply 2×2 matrices by hand
Interpret an eigenvalue
Apply Bayes' rule
Expectation and variance of a discrete RV
Summarize a small dataset
Construct a 95% confidence interval
Interpret a p-value correctly
Fit a simple linear regression
Compute a 2D gradient
Independence and inclusion-exclusion
Normal tail probability
Correlation pitfalls
Type I vs Type II errors
Match distribution to scenario
CLT and required sample size
Standard error vs standard deviation
Design an A/B test with power
Interpret a sample ratio mismatch
Beta-Binomial posterior update
MLE for Bernoulli trials
Compute cross-entropy in bits
Compute covariance and correlation matrix
Diagnose overfit with a train/holdout split
Identify rank and column space
PCA variance explained
Log returns and annualized volatility
Interpret an ACF plot
Simulate a two-state Markov chain
Sharpe ratio and max drawdown
Design an honest momentum backtest
Condition number and learning rate
Latency against utilisation
Distances concentrate as dimensions grow
Count with inclusion-exclusion
Log-sum-exp without overflow

Vector DB & ANN

Embed a corpus and search it
Implement similarity metrics
Top-k with a bounded heap
Build a brute-force vector index
Explain HNSW search on paper
Add metadata filtering to vector search
IVF nprobe vs recall
PQ codebook footprint
Read a recall–latency curve
Scalar quantise and rescore
Cost a disk-resident search by I/O
Tombstones erode recall

AI Systems

Build a minimal RAG pipeline
Build a structure-aware chunker
Schema-constrained extraction
Build a tool-calling loop
Build an LLM eval
Dot product and matmul shapes
One SGD step on a quadratic
Chain rule on a tiny graph
Softmax and cross-entropy loss
AdamW vs L2-on-gradient
One BPE merge step
Perplexity from average NLL
Temperature scaling logits
Sinusoidal position encoding
Scaled dot-product attention weights
Split embedding across heads
Pre-LayerNorm residual block
Overfit a single batch sanity check
Checkpoint must include optimizer state
GRPO group-relative advantage
LoRA parameter count
Estimate training token budget
WASM linear memory growth
WebGPU buffer upload size
Perplexity vs classification accuracy
Pack chunks into context budget
Cap agent tool loop
Route by cost and difficulty
Diff two prompt versions
Design exercise: Model Pre-training
Design exercise: Model Quantization
Design exercise: Open-Weight Models

Backend

Implement a token-bucket rate limiter
Implement idempotency keys
Implement backoff with jitter
Idempotent POST retry
Hash and prefix API keys
Verify webhook HMAC
At-least-once job delivery
Cache stampede
Queue backpressure
SLO error budget
Design cursor pagination
JWT revocation tradeoff
Idempotent charge
Design exercise: Observability & OpenTelemetry
Exponential backoff with full jitter
Parameterise instead of escaping
Cursor pagination that survives inserts

Databases & Storage

Build a memtable + SSTable flush
Build a write-ahead log
B-tree page split
LSM compaction levels
Object key layout
Columnar vs row store
Secondary index write cost
Storage vs retrieval API
Pick a shard key
Read-your-writes under lag
CAP under partition
Design exercise: Transaction Processing
Design exercise: Query Execution & Optimization
Design exercise: Data Warehouses & Lakehouses
Detect write skew under snapshot isolation
Pick the join the planner should pick
Spot the update anomaly
Why LRU-K survives a scan

System Design

DSA & Implementation

Two Sum with a hash map
Valid palindrome with two pointers
Longest substring without repeats
Search in a rotated sorted array
Binary tree level-order traversal
Number of islands
House robber (1D DP)
Kth largest element with a heap
Valid parentheses with a stack
Reverse a linked list in place
Trie prefix membership
Generate all subsets
Dijkstra shortest path
Union-find component count
Minimum path sum in a grid
Activity selection greedy
Merge overlapping intervals
GCD and modulo arithmetic
Find the single number (XOR)
Two Sum
Valid Palindrome
Best Time to Buy and Sell Stock
Contains Duplicate
Maximum Subarray
3Sum
Longest Substring Without Repeating Characters
Valid Parentheses
Merge Two Sorted Lists
Binary Search
Number of Islands
Climbing Stairs
Coin Change
House Robber
Product of Array Except Self
Group Anagrams
Top K Frequent Elements
Invert Binary Tree
Maximum Depth of Binary Tree
Kth Largest Element in an Array
Word Search
Permutations
Jump Game
Merge Intervals
Single Number
Lowest Common Ancestor of a Binary Search Tree
Serialize and Deserialize Binary Tree
Course Schedule
Rotting Oranges
Task Scheduler
Subtree of Another Tree
Daily Temperatures
Car Fleet
Non-overlapping Intervals
Sum of Two Integers
Reverse Bits
Amortised growth of a dynamic array
Stable sort by one key
Answer range-sum queries in O(1)
Next greater element
Rabin-Karp substring search
Total weight of a minimum spanning tree
Solve a divide-and-conquer recurrence
k-th smallest by quickselect

Behavioral & Communication

STAR: leadership story
STAR: peer conflict
STAR: tough decision
STAR: cross-team collab
STAR: a real failure
STAR: explaining to a non-expert
STAR: ruthless prioritization
STAR: an unconventional idea
STAR: acting on customer feedback
STAR: end-to-end ownership

Go-to-Market

Draft a product positioning statement
Critique a real landing page
On-page SEO audit
Define a north-star metric

Systems Foundations

Concurrent bank transfers
Design exercise: Operating System Mechanics
Design exercise: Network Protocol Engineering
Design exercise: Compute, Memory & Storage Hierarchy
Design exercise: Runtime & Performance Engineering
Design exercise: Security & Isolation Boundaries
Encode a binary compatibility fixture
Trace a program into process memory

Infrastructure & Platforms

Implement backoff with jitter
At-least-once job delivery
SLO error budget
Design exercise: Cloud Infrastructure
Design exercise: Containers & Kubernetes
Design exercise: CI/CD & Developer Environments
Design exercise: Scheduling & Orchestration
Design exercise: Reliability & Fault Tolerance
Design exercise: Observability & OpenTelemetry
Design exercise: Sandboxes & Execution Environments
Design exercise: Infrastructure Automation

Distributed Systems

Distributed rate limiter
Realtime chat system
Leader election walkthrough
Cache stampede
Queue backpressure
Pick a shard key
Read-your-writes under lag
CAP under partition
Design exercise: Event Streaming & Kafka
Design exercise: Distributed Workflows & Temporal
Design exercise: Distributed Failure Recovery
Design exercise: Real-time Application Engineering

Inference & Serving

WASM linear memory growth
WebGPU buffer upload size
Route by cost and difficulty
Design exercise: vLLM & Inference Engines
Design exercise: Continuous Batching
Design exercise: KV Caching & PagedAttention
Design exercise: FlashAttention & Attention Kernels
Design exercise: Speculative Decoding
Design exercise: GPU Utilization
Design exercise: Inference Cost & Latency Optimization
Design exercise: Local & On-device Inference
Design exercise: Inference Hardware

Agent Systems

Build a tool-calling loop
Cap agent tool loop
Design exercise: Agent Memory & Context Management
Design exercise: MCP & Integrations
Design exercise: Multi-agent Coordination
Design exercise: Durable Agent Execution
Design exercise: Agent Permissions & Sandboxing
Design exercise: Browser & Computer-use Agents
Design exercise: Agent Communication & Interfaces
Design exercise: Long-running & Scheduled Agents
Build a scoped repository instruction map
Define an agent-readable environment contract
Create a durable agent handoff
Enforce runtime scope and escalation
Separate maker claims from checker evidence
Implement a bounded agent run lifecycle
Evaluate and ablate an agent harness

Evaluation & AI Reliability

Build an LLM eval
Perplexity vs classification accuracy
Diff two prompt versions
Design exercise: Coding-agent Benchmarks
Design exercise: Tool-use Evaluations
Design exercise: AI Regression Testing
Design exercise: Hallucination & Failure Detection
Design exercise: Agent Observability
Design exercise: Tracing & Replay
Design exercise: Evidence-backed Verification
Design exercise: Human Review Systems
Design exercise: Quality, Cost & Latency Measurement
Separate maker claims from checker evidence
Evaluate and ablate an agent harness

Developer Tools & Code Intelligence

Design exercise: Code Review Systems
Design exercise: Static & Dynamic Analysis
Design exercise: Testing Infrastructure
Design exercise: Codebase Graphs
Design exercise: Dependency & Blast-radius Analysis
Design exercise: IDE & CLI Tooling
Design exercise: Coding Agent Systems
Design exercise: Repository Intelligence
Design exercise: Software Supply-chain Health
Design exercise: Automated Debugging & Remediation
Build a scoped repository instruction map
Define an agent-readable environment contract
Enforce runtime scope and escalation

Application Engineering

Realtime game server
Design exercise: Web & Mobile Engineering
Design exercise: UX & Interface Design
Design exercise: 2D/3D Interactive Systems

Multimodal & Spatial Computing

Design exercise: Multimodal Models
Design exercise: Vision Models
Design exercise: Pose & Motion Tracking
Design exercise: Voice & Audio Systems
Design exercise: Image & Video Generation
Design exercise: Robotics Systems
Design exercise: Spatial Interfaces
Design exercise: Human-Computer Interaction

All practice prompts

Build a search tokenizer
Build an inverted index
Calculate a TF-IDF score by hand
Calculate a BM25 score by hand
Implement a BM25 ranker
Compute precision and recall by hand
Build a search eval harness
Implement reciprocal rank fusion
Embed a corpus and search it
Implement similarity metrics
Top-k with a bounded heap
Build a brute-force vector index
Explain HNSW search on paper
Add metadata filtering to vector search
Build a minimal RAG pipeline
Build a structure-aware chunker
Schema-constrained extraction
Build a tool-calling loop
Build an LLM eval
Implement a token-bucket rate limiter
Implement idempotency keys
Implement backoff with jitter
Build a memtable + SSTable flush
Build a write-ahead log
Two Sum with a hash map
Valid palindrome with two pointers
Longest substring without repeats
Search in a rotated sorted array
Binary tree level-order traversal
Number of islands
House robber (1D DP)
Kth largest element with a heap
Design a parking lot
Design a vending machine
Pluggable pricing strategies
In-process pub/sub bus
Notification factory
Coffee-shop order decorator
Concurrent bank transfers
Undo / redo stack
Hotel booking system
L7 load balancer
Distributed rate limiter
Realtime chat system
News feed (Twitter-style)
Video streaming (Netflix-style)
Ride-sharing dispatch
Make three replicas converge
Collaborative doc editor
Search platform end-to-end
Production RAG pipeline
Consistent-hash key router
Leader election walkthrough
Realtime game server
STAR: leadership story
STAR: peer conflict
STAR: tough decision
STAR: cross-team collab
STAR: a real failure
STAR: explaining to a non-expert
STAR: ruthless prioritization
STAR: an unconventional idea
STAR: acting on customer feedback
STAR: end-to-end ownership
Draft a product positioning statement
Critique a real landing page
On-page SEO audit
Define a north-star metric
Compute a dot product and angle
Multiply 2×2 matrices by hand
Interpret an eigenvalue
Apply Bayes' rule
Expectation and variance of a discrete RV
Summarize a small dataset
Construct a 95% confidence interval
Interpret a p-value correctly
Fit a simple linear regression
Compute a 2D gradient
Independence and inclusion-exclusion
Normal tail probability
Correlation pitfalls
Type I vs Type II errors
Match distribution to scenario
CLT and required sample size
Standard error vs standard deviation
Design an A/B test with power
Interpret a sample ratio mismatch
Beta-Binomial posterior update
MLE for Bernoulli trials
Compute cross-entropy in bits
Compute covariance and correlation matrix
Diagnose overfit with a train/holdout split
Identify rank and column space
PCA variance explained
Log returns and annualized volatility
Interpret an ACF plot
Simulate a two-state Markov chain
Sharpe ratio and max drawdown
Design an honest momentum backtest
Dot product and matmul shapes
One SGD step on a quadratic
Chain rule on a tiny graph
Softmax and cross-entropy loss
AdamW vs L2-on-gradient
One BPE merge step
Perplexity from average NLL
Temperature scaling logits
Sinusoidal position encoding
Scaled dot-product attention weights
Split embedding across heads
Pre-LayerNorm residual block
Overfit a single batch sanity check
Checkpoint must include optimizer state
GRPO group-relative advantage
LoRA parameter count
Estimate training token budget
WASM linear memory growth
WebGPU buffer upload size
Perplexity vs classification accuracy
Valid parentheses with a stack
Reverse a linked list in place
Trie prefix membership
Generate all subsets
Dijkstra shortest path
Union-find component count
Minimum path sum in a grid
Activity selection greedy
Merge overlapping intervals
GCD and modulo arithmetic
Find the single number (XOR)
Cross-encoder rerank top-k
Spell-correct a search query
Browse vs search metrics
IVF nprobe vs recall
PQ codebook footprint
Read a recall–latency curve
Pack chunks into context budget
Cap agent tool loop
Route by cost and difficulty
Diff two prompt versions
Idempotent POST retry
Hash and prefix API keys
Verify webhook HMAC
At-least-once job delivery
Cache stampede
Queue backpressure
SLO error budget
Design cursor pagination
JWT revocation tradeoff
Idempotent charge
B-tree page split
LSM compaction levels
Object key layout
Columnar vs row store
Secondary index write cost
Storage vs retrieval API
Pick a shard key
Read-your-writes under lag
CAP under partition
Condition number and learning rate
Two Sum
Valid Palindrome
Best Time to Buy and Sell Stock
Contains Duplicate
Maximum Subarray
3Sum
Longest Substring Without Repeating Characters
Valid Parentheses
Merge Two Sorted Lists
Binary Search
Number of Islands
Climbing Stairs
Coin Change
House Robber
Product of Array Except Self
Group Anagrams
Top K Frequent Elements
Invert Binary Tree
Maximum Depth of Binary Tree
Kth Largest Element in an Array
Word Search
Permutations
Jump Game
Merge Intervals
Single Number
Lowest Common Ancestor of a Binary Search Tree
Serialize and Deserialize Binary Tree
Course Schedule
Rotting Oranges
Task Scheduler
Subtree of Another Tree
Daily Temperatures
Car Fleet
Non-overlapping Intervals
Sum of Two Integers
Reverse Bits
Design exercise: Operating System Mechanics
Design exercise: Network Protocol Engineering
Design exercise: Compute, Memory & Storage Hierarchy
Design exercise: Runtime & Performance Engineering
Design exercise: Security & Isolation Boundaries
Design exercise: Cloud Infrastructure
Design exercise: Containers & Kubernetes
Design exercise: CI/CD & Developer Environments
Design exercise: Scheduling & Orchestration
Design exercise: Reliability & Fault Tolerance
Design exercise: Observability & OpenTelemetry
Design exercise: Sandboxes & Execution Environments
Design exercise: Infrastructure Automation
Design exercise: Event Streaming & Kafka
Design exercise: Distributed Workflows & Temporal
Design exercise: Distributed Failure Recovery
Design exercise: Transaction Processing
Design exercise: Query Execution & Optimization
Design exercise: Data Warehouses & Lakehouses
Design exercise: Model Pre-training
Design exercise: Model Quantization
Design exercise: Open-Weight Models
Design exercise: vLLM & Inference Engines
Design exercise: Continuous Batching
Design exercise: KV Caching & PagedAttention
Design exercise: FlashAttention & Attention Kernels
Design exercise: Speculative Decoding
Design exercise: GPU Utilization
Design exercise: Inference Cost & Latency Optimization
Design exercise: Local & On-device Inference
Design exercise: Inference Hardware
Design exercise: Agent Memory & Context Management
Design exercise: MCP & Integrations
Design exercise: Multi-agent Coordination
Design exercise: Durable Agent Execution
Design exercise: Agent Permissions & Sandboxing
Design exercise: Browser & Computer-use Agents
Design exercise: Agent Communication & Interfaces
Design exercise: Long-running & Scheduled Agents
Design exercise: Coding-agent Benchmarks
Design exercise: Tool-use Evaluations
Design exercise: AI Regression Testing
Design exercise: Hallucination & Failure Detection
Design exercise: Agent Observability
Design exercise: Tracing & Replay
Design exercise: Evidence-backed Verification
Design exercise: Human Review Systems
Design exercise: Quality, Cost & Latency Measurement
Design exercise: Code Review Systems
Design exercise: Static & Dynamic Analysis
Design exercise: Testing Infrastructure
Design exercise: Codebase Graphs
Design exercise: Dependency & Blast-radius Analysis
Design exercise: IDE & CLI Tooling
Design exercise: Coding Agent Systems
Design exercise: Repository Intelligence
Design exercise: Software Supply-chain Health
Design exercise: Automated Debugging & Remediation
Design exercise: Web & Mobile Engineering
Design exercise: UX & Interface Design
Design exercise: Real-time Application Engineering
Design exercise: 2D/3D Interactive Systems
Design exercise: Multimodal Models
Design exercise: Vision Models
Design exercise: Pose & Motion Tracking
Design exercise: Voice & Audio Systems
Design exercise: Image & Video Generation
Design exercise: Robotics Systems
Design exercise: Spatial Interfaces
Design exercise: Human-Computer Interaction
Amortised growth of a dynamic array
Stable sort by one key
Size a write-heavy service
Split functional from non-functional
Answer range-sum queries in O(1)
Next greater element
Rabin-Karp substring search
Total weight of a minimum spanning tree
Detect write skew under snapshot isolation
Pick the join the planner should pick
Exponential backoff with full jitter
Parameterise instead of escaping
Latency against utilisation
Distances concentrate as dimensions grow
Skip documents that cannot reach the top k
Token bucket rate limiter
Pack and unpack a Snowflake id
Solve a divide-and-conquer recurrence
k-th smallest by quickselect
Spot the update anomaly
Why LRU-K survives a scan
Cursor pagination that survives inserts
Count with inclusion-exclusion
Log-sum-exp without overflow
NDCG@k
Debias clicks by inverse propensity
Scalar quantise and rescore
Cost a disk-resident search by I/O
Tombstones erode recall
Decide the edge cache key
Encode a binary compatibility fixture
Trace a program into process memory
Build a scoped repository instruction map
Define an agent-readable environment contract
Create a durable agent handoff
Enforce runtime scope and escalation
Separate maker claims from checker evidence
Implement a bounded agent run lifecycle
Evaluate and ablate an agent harness