All tracks

Two Sum, three ways

Step through brute force, two pointers and a hash map. Then scale n and see the gap.

Open session →

Hash map: group anagrams

Give every word a key, then one lookup per word puts anagrams in the same bucket.

Open session →

Two pointers: most water

Start at both ends and always move the shorter line. One pass instead of every pair.

Open session →

Sliding window

Slide a fixed window and watch each step add one cell and drop one.

Open session →

Prefix sums: range sums in O(1)

Build running totals once, then any range is one subtraction.

Open session →

Monotonic stack: next warmer day

Keep the waiting days on a stack and answer each one the moment a warmer day arrives.

Open session →

Binary search

Halve the search space and see why it takes log n steps.

Open session →

Fast and slow pointers

Two pointers at different speeds find a cycle, and where it starts, with no extra memory.

Open session →

LRU cache

A hash map plus a doubly linked list gives O(1) get, put and eviction.

Open session →

Merge overlapping intervals

Sort by start, then each interval only needs comparing with the last merged one.

Open session →

Heap: top k of a stream

Keep the k largest in a min-heap and reject most numbers with one comparison.

Open session →

Trees: let the children answer first

Find a tree's depth one call at a time and watch the call stack grow and shrink with it.

Open session →

Trie: prefix lookups

Walk one node per letter, then collect every word below.

Open session →

BFS vs DFS

Run both on the same graph and compare the order they visit nodes.

Open session →

Union-find: connected groups

Merge groups as edges arrive and tell instantly whether two items are connected.

Open session →

Topological sort

Count prerequisites, start with the zeros, unlock the rest, and detect cycles.

Open session →

Dijkstra: shortest paths

Settle the closest node, relax its edges, repeat.

Open session →

Backtracking: choose, explore, undo

Walk a decision tree of take-or-skip choices and prune branches that can't work.

Open session →

Dynamic programming: coin change

Fill a table from 0 upward so every answer is worked out once, and see where greedy goes wrong.

Open session →

The event loop, phase by phase

Queue timers, promises and I/O, then step through each loop phase.

Open session →

Streams and backpressure

Push data faster than it drains and watch the buffer fill.

Open session →

The libuv thread pool

Fire file and crypto work and see which calls block the pool.

Open session →

Don't block the event loop

One 200 ms calculation stalls every request, until it moves to a worker thread.

Open session →

Vertical vs horizontal scaling

Make one server bigger or add more servers, and see where each one hits a wall.

Open session →

Back-of-the-envelope estimates

Turn daily users into requests per second, storage and bandwidth.

Open session →

Load balancing strategies

Queues, health checks, and timeouts — not just which server is next.

Open session →

Autoscaling

Add servers when traffic climbs and remove them when it drops, without flapping.

Open session →

Caching and eviction

Watch a cache hit, miss and evict, then predict the next request.

Open session →

Cache invalidation

Write-through, write-behind, TTLs and explicit purges: keeping cached data fresh.

Open session →

CDNs: caching at the edge

Pick a TTL, ship a new logo, and see which cities still get the old one.

Open session →

Latency, throughput and concurrency

Why a faster request and more requests per second are different goals.

Open session →

Rate limiting

Fixed window, sliding window and token bucket on the same burst.

Open session →

Backpressure and load shedding

Slow the sender or drop work on purpose before the whole system falls over.

Open session →

Counting at scale: HyperLogLog and count-min sketch

Count unique visitors and frequent items in kilobytes, by accepting a small error.

Open session →

Top-K, trending and leaderboards

Rank millions of scores live, and find what's trending right now.

Open session →

Replication and stale reads

Write to the leader, read from a follower, and crash the leader mid-write.

Open session →

Sharding: choosing the shard key

Hash, country or date: see hot shards and queries that ask every shard.

Open session →

Bloom filters

Answer "definitely not here" without touching the database, with a tunable false-positive rate.

Open session →

Change data capture

Stream every database change to search, caches and analytics without dual writes.

Open session →

Zero-downtime schema migrations

Change a table under live traffic: expand, migrate, then contract.

Open session →

DNS, TCP, TLS and HTTP: one request

Follow a request from a domain name to a response, one layer at a time.

Open session →

API gateways and service discovery

One front door for auth, routing and limits, and how it finds services that move.

Open session →

Idempotency and request deduplication

Send the same payment twice and charge it once.

Open session →

Webhooks

Call another system when something happens: signatures, retries and replay.

Open session →

Availability and the nines

What 99.9% really allows, and how redundancy buys more nines.

Open session →

Fault tolerance and graceful degradation

Turn off the extras so the core feature keeps working.

Open session →

Retries and circuit breakers

Turn a retry storm into a fast failure and let the broken service recover.

Open session →

Bulkheads

Split resources so one slow dependency can't use up every thread.

Open session →

Failover, disaster recovery, RTO and RPO

Lose a region and measure how long you're down and how much data you lose.

Open session →

CAP theorem and quorums

Split the network and choose: answer with stale data, or refuse until it heals.

Open session →

Hedged requests and retry budgets

Send a backup request to cut slow tails, without doubling the load.

Open session →

Message queues

Slow consumers, duplicate charges and a dead-letter queue: at-least-once in action.

Open session →

Ordering, delivery guarantees and duplicates

At-most-once, at-least-once, exactly-once, and keeping events in order.

Open session →

Eventual consistency

Replicas disagree for a moment, then converge. When is that acceptable?

Open session →

CQRS and event sourcing

Store every change as an event and build separate read models from them.

Open session →

Sagas and the transactional outbox

Run a multi-service order without a global transaction, and never lose the event.

Open session →

Leader election and consensus

Nodes vote in a leader with Raft; crash it and watch them elect another.

Open session →

Distributed locks

Only one worker may run the job: leases, fencing tokens and expired locks.

Open session →

Consistent hashing

Add and remove nodes and see how few keys move.

Open session →

Unique IDs at scale

Auto-increment, UUIDs and Snowflake IDs: ordering, collisions and coordination.

Open session →

Clocks and ordering

Machine clocks drift: Lamport and vector clocks order events without them.

Open session →

Gossip protocols

Spread membership and state through a cluster by talking to a few peers at a time.

Open session →

Merkle trees and anti-entropy

Find which data two replicas disagree on without comparing every row.

Open session →

Blue-green and canary deployments

Ship to a small slice of traffic first, and roll back in seconds.

Open session →

Feature flags

Ship code dark, turn it on for 1% of users, and switch it off without a deploy.

Open session →

Real-time: WebSockets, SSE and presence

Push live updates and show who is online, and what each approach costs.

Open session →

Background jobs and scheduling

Workers, retries, cron and dead-letter queues for work users shouldn't wait on.

Open session →

Multi-tenancy

Keep each customer's data apart, with per-tenant settings and limits.

Open session →

Streaming responses

Send tokens as they're generated, through every hop to the browser.

Open session →

Processes, signals and systemd

Start, stop and supervise programs, and what happens on kill -9.

Open session →

Files, users and permissions

Who can read, write and run what, and why chmod 777 is a bad fix.

Open session →

CPU, memory and disk

Read top, free and df, and find what is slowing the machine down.

Open session →

IP addresses, subnets and CIDR

What 10.0.0.0/16 means, and how to split a network into subnets.

Open session →

DNS records in practice

A, CNAME, MX and TXT records, TTLs, and why a DNS change takes time.

Open session →

Reverse proxies in practice

Put NGINX in front of an app: routing, headers and timeouts.

Open session →

VPCs, public and private subnets

Keep databases off the internet and still let servers reach out.

Open session →

How Git stores history

Commits, trees and blobs: what a branch really is.

Open session →

Trunk-based development vs GitFlow

Short-lived branches or long release branches, and how each affects merges.

Open session →

Semantic versioning and releases

Version numbers, changelogs and tagging a release.

Open session →

Containers vs virtual machines

Start a container, then boot a VM, and see what each one shares.

Open session →

Images and layers

How an image is built from layers, and why order in a Dockerfile matters.

Open session →

Writing a good Dockerfile

Build caching, multi-stage builds and small images.

Open session →

Container networking

Bridges, port mapping and containers finding each other by name.

Open session →

Volumes and persistent data

Keep data when the container is deleted.

Open session →

A CI/CD pipeline, stage by stage

Break a test or a build and see where the pipeline stops.

Open session →

Build caching and artifacts

Stop rebuilding what didn't change, and keep the exact build you ship.

Open session →

GitOps

Git is the source of truth; a controller makes the cluster match it.

Open session →

Software supply chain security

Lock files, SBOMs, signed images and trusting what you deploy.

Open session →

Kubernetes rolling deploys

Roll out a bad version and watch probes and rollback kick in.

Open session →

Services and Ingress

Give pods a stable address and route outside traffic to them.

Open session →

Liveness, readiness and startup probes

Tell Kubernetes when to restart a pod and when to send it traffic.

Open session →

Requests, limits and OOM kills

Reserve CPU and memory, and see what happens when a pod uses too much.

Open session →

Horizontal pod autoscaling

Add pods when CPU or queue length climbs.

Open session →

Scheduling, taints and affinity

Decide which pods land on which nodes.

Open session →

Terraform: plan and apply

Describe infrastructure, preview the change, then apply it.

Open session →

State, locking and drift

Where Terraform remembers what exists, and what happens when someone clicks in the console.

Open session →

Regions and availability zones

Spread across zones so one data center failing doesn't take you down.

Open session →

Serverless functions

Cold starts, timeouts, concurrency limits and paying per call.

Open session →

Cloud cost management

See where the bill comes from and cut it: rightsizing, reserved and spot capacity.

Open session →

Structured logs and log aggregation

JSON logs, shipped to one place, searchable by request ID.

Open session →

Metrics with Prometheus

Counters, gauges and histograms, scraped and queried.

Open session →

Tracing with OpenTelemetry

Instrument services once and send traces anywhere.

Open session →

SLIs, SLOs and error budgets

Agree how reliable is reliable enough, and spend the rest on shipping.

Open session →

Backups and restore drills

A backup you have never restored is not a backup.

Open session →

DORA metrics

Deploy frequency, lead time, change failure rate and time to restore.

Open session →

From URL to pixels

Everything that happens after you press Enter, in order.

Open session →

The cascade and specificity

Why this rule won over that one.

Open session →

Style, layout, paint and composite

The four stages that turn the DOM into pixels.

Open session →

The browser event loop

Tasks, microtasks and when the screen gets a chance to update.

Open session →

Event bubbling and capturing

How one click travels down and back up the tree.

Open session →

Web workers

Move heavy work off the main thread.

Open session →

Closures and scope

Functions that remember the variables around them.

Open session →

How this is decided

Four rules that decide what this points to.

Open session →

Prototypes and classes

What a class really is underneath.

Open session →

Promises and async/await

What await actually pauses, and what keeps running.

Open session →

The box model

Content, padding, border and margin, and box-sizing.

Open session →

Flexbox

Grow, shrink and basis: how space is shared along a line.

Open session →

CSS Grid

Rows, columns and areas for two-dimensional layout.

Open session →

Positioning and stacking contexts

Why z-index: 9999 still sits behind something.

Open session →

Responsive design

Media queries, container queries and fluid sizes.

Open session →

Animations and transitions

Which properties animate cheaply and which cause jank.

Open session →

Rendering and reconciliation

Render, diff, commit: how React updates the DOM.

Open session →

Why components re-render

State, props, context and parents: every trigger, made visible.

Open session →

useState and useEffect, step by step

When state updates land and when effects run.

Open session →

memo, useMemo and useCallback

Skip work you don't need, and when it doesn't help.

Open session →

Data fetching and caching

Stale-while-revalidate, deduplication and refetching.

Open session →

Optimistic updates

Show the change now, roll back if the server says no.

Open session →

CSR, SSR, SSG and ISR

Render in the browser, on each request, at build time, or in between.

Open session →

Hydration

Make server HTML interactive, and why mismatches happen.

Open session →

Core Web Vitals

LCP, INP and CLS: what each measures and what hurts it.

Open session →

Code splitting and lazy loading

Load only the code this page needs.

Open session →

Images and fonts

Formats, sizes, lazy loading and avoiding layout shift.

Open session →

Browser caching and service workers

Cache headers, revalidation and working offline.

Open session →

Long tasks and a blocked main thread

Why the page freezes, and how to break work up.

Open session →

Cookies, localStorage and IndexedDB

Where to keep data in the browser, and who can read it.

Open session →

CORS

Why the browser blocks the request, and how the server allows it.

Open session →

Content Security Policy

Tell the browser which scripts it may run.

Open session →

Keyboard and focus

Tab order, focus traps and visible focus.

Open session →

Window functions

Running totals and rankings without collapsing rows.

Open session →

Nested loop, hash and merge joins

Three ways to join tables, and when each wins.

Open session →

B-tree indexes

How an index finds one row among millions.

Open session →

Composite and covering indexes

Column order, and answering a query from the index alone.

Open session →

LSM trees

Fast writes with memtables, SSTables and compaction.

Open session →

The lost update

Two deposits at once and one disappears: four ways to stop it.

Open session →

MVCC

Readers don't block writers: row versions and snapshots.

Open session →

The write-ahead log

Write the change to the log first, then to the table.

Open session →

Connection pooling

Why 1,000 app servers can't each open 100 connections.

Open session →

Read replicas and lag

Spread reads, and handle data that's a few seconds old.

Open session →

Table partitioning

Split one huge table by date or key.

Open session →

NAT and private networks

Many devices behind one public address.

Open session →

The TCP handshake

SYN, SYN-ACK, ACK, and what it costs in round trips.

Open session →

Flow control

The receive window stops a fast sender drowning a slow receiver.

Open session →

Congestion control

Slow start, backing off on loss, and sharing the link.

Open session →

How routers forward packets

Routing tables and the next hop.

Open session →

Traceroute and latency

See every hop and where the time goes.

Open session →

DNS resolution, hop by hop

Stub resolver, recursive resolver, root, TLD, authoritative.

Open session →

HTTP/2 multiplexing

Many requests on one connection.

Open session →

Latency vs bandwidth

A wider pipe doesn't make the first byte arrive sooner.

Open session →

Registers, caches and RAM

Why some reads take 1 ns and others 100 ns.

Open session →

Cache lines and locality

Why looping over an array the right way is faster.

Open session →

CPU scheduling

Who runs next: round robin, priorities and fairness.

Open session →

Virtual memory and paging

Every process thinks it has the whole memory to itself.

Open session →

Garbage collection

Mark and sweep, generations and pauses.

Open session →

Race conditions

Two threads update one counter and lose an increment.

Open session →

Deadlocks

Two threads each hold what the other needs.

Open session →

Condition variables and producer-consumer

Wait for work without spinning.

Open session →

Event loops and epoll

One thread watching thousands of connections.

Open session →

Storing passwords

Salts, bcrypt and argon2, and why plain hashes fail.

Open session →

Key exchange

Two strangers agree on a secret over a public channel.

Open session →

Digital signatures

Prove who sent a message and that nobody changed it.

Open session →

Certificates and certificate authorities

The chain of trust from your site to the browser.

Open session →

JWTs

What's inside a token, and the mistakes that make it forgeable.

Open session →

The OAuth 2.0 flow

Authorization code with PKCE, step by step.

Open session →

Cross-site scripting (XSS)

Injected script running in someone else's session.

Open session →

Cross-site request forgery (CSRF)

Another site makes the user's browser send a request.

Open session →

SQL injection

User input that changes the query.

Open session →

Server-side request forgery (SSRF)

Trick the server into calling internal addresses.

Open session →

Broken access control

Change an ID in the URL and see someone else's data.

Open session →

Training: loss and gradient descent

Nudge every parameter downhill until the error stops falling.

Open session →

Overfitting and train/test splits

A model that memorizes the training set and fails on new data.

Open session →

Neural networks, layer by layer

Weights, activations and how stacking layers learns features.

Open session →

How text becomes tokens

Train a tiny BPE tokenizer merge by merge, then type your own text and count the tokens.

Open session →

Token embeddings and positions

Look up each token's row, add a vector for its position, and see why “dog bit man” needs it.

Open session →

Attention, one head

Pick a word and see which words it looks at: score, scale, mask, softmax, blend.

Open session →

A transformer block

LayerNorm, attention, feed-forward and residual adds on real numbers. Turn residuals off and the tokens blur together.

Open session →

How an LLM picks the next token

Drag temperature, top-k and top-p. Watch the odds move, then sample.

Open session →

The KV cache

Why the first token is slow, the rest are fast, and long chats cost memory.

Open session →

Pretraining

Clean the text, guess every next token, measure the loss, nudge the weights. Train a tiny model batch by batch.

Open session →

Instruction tuning and RLHF

One prompt through pretraining, SFT and RLHF. Loosen the KL leash and watch reward hacking set in.

Open session →

Scaling laws

More data, parameters and compute: what improves, and how fast.

Open session →

Why models hallucinate

Rare facts get thin probabilities but fluent answers. Try retrieval, “not sure”, and grading that stops rewarding guesses.

Open session →

The context window, turn by turn

Play a long chat and watch the prompt fill the window. Then trim it, and see what it costs.

Open session →

Long context vs retrieval

Paste the whole document, or fetch only the relevant parts?

Open session →

Embeddings and similarity search

Move a query in vector space and see which notes come back.

Open session →

Chunking strategies

Fixed size, overlap or by heading: see which one cuts the answer in half.

Open session →

Hybrid search and reranking

Keyword search, vector search, rank fusion and a reranker. See which one finds the right note.

Open session →

RAG, step by step

Chunk, retrieve and prompt, and see what the model actually gets.

Open session →

Query rewriting and HyDE

Rewrite a vague question before searching, so retrieval finds more.

Open session →

Agent patterns: workflow or agent?

Chaining, routing, parallel calls, orchestrator-workers, evaluator loops and a true agent, side by side.

Open session →

The ReAct loop

Think, act, observe, repeat, until the task is done.

Open session →

Evals: is the new prompt better?

Grade two prompt versions with code checks and an LLM judge, then check the judge against people.

Open session →

Evaluation metrics

Exact match, similarity scores, faithfulness and when each misleads.

Open session →

LLM-as-judge and its biases

A model grading a model: position bias, length bias and self-preference.

Open session →

LoRA and parameter-efficient tuning

Train a small add-on instead of the whole model.

Open session →

Force valid JSON

Turn a schema on and watch illegal tokens get refused.

Open session →

Call a tool, then answer

Give the model a weather tool, then take it away and watch it guess.

Open session →

Streaming UI and partial results

Show the answer as it arrives, and handle half-finished output.

Open session →

Designing for slow responses

Progress, skeletons and doing work before the user asks.

Open session →

Cost per feature and per user

Price an AI feature before it surprises the bill.

Open session →

A/B testing AI features

Compare prompts or models on real users safely.

Open session →

One item through a workflow

Send three different emails down the same path and watch the branch change.

Open session →

Run it on a schedule

Fire the same workflow on a clock and see what a missed run does.

Open session →

Retries and error handling

Retry what's temporary, alert on what isn't.

Open session →

Classify and route

Let a model decide which branch an item takes.

Open session →

Confidence thresholds and fallbacks

Act alone when sure, ask for help when not.

Open session →

Pause for a person

Draft a refund, then approve or reject it before anything is sent.

Open session →

A coding agent's loop

Watch search, edit, and a check repeat until the test passes.

Open session →

MCP: tools the model can call

A server lists tools. The app forwards the one the model picks.

Open session →

Building an MCP server

Expose your own data and actions to any MCP client.

Open session →

An n8n workflow, node by node

Cross a threshold and see the run switch from email to Slack.

Open session →

Model routers

OpenRouter-style services: one key, many models, automatic fallback.

Open session →

GitHub Actions on every push

Follow a workflow file from the push event to the job log.

Open session →