Learning Paths

SQL, NoSQL, schema design, indexes, and choosing the right store.

Twelve database types from SQL and NewSQL through vector, graph, and ledger stores.

Decision guide across relational, document, vector, and graph databases.

Schema, scaling, queries, and when to use each — with a decision guide.

Cache-aside, Redis, eviction policies, CDN, and multi-level caching.

Why cache, latency ladder, seven layers, hit/miss flow, and eviction policies.

Six architectural reasons — in-memory, single-thread, structures, O(1) ops, event I/O.

Async frees threads during I/O waits — scalability, not single-request speed.

REST, gRPC, message queues, sagas, and resilience patterns.

REST, GraphQL, WebSocket, gRPC, and SOAP at each architectural layer.

Short polling, long polling, SSE, and WebSockets — timelines and when to use each.

Pick the right message broker for your workload.

Point-to-point, work queues, and fanout broadcast — with correct pub-sub vocabulary.

When to start simple, when to split, and how modular monoliths bridge the gap.

Scalability, load balancing, CAP theorem, and design case studies.

A taxonomy and decision guide for naive, memory, agentic, graph, HyDE, Self-RAG, CRAG, and multimodal RAG.

A workflow-first market map across AI tools for websites, work, support, media, marketing, and documents.

Eight stack layers across infrastructure, models, orchestration, retrieval, memory, and evals.

Prompt, tokens, embeddings, transformer blocks, logits, decoding, and generated text.

Retrieval and generation are scored as separate systems.

Hit rate, recall, MRR, and nDCG measure different retrieval promises.

Answers must be checked against evidence, not only fluency.

Lexical and vector retrieval catch different relevance signals.

Filters are authorization and precision controls before ranking.

Vector spaces are not interchangeable, so migration needs dual-write and backfill.

Context windows and retrieval solve different evidence-selection problems.

Bi-encoders retrieve broadly while rerankers inspect pairs more carefully.

Rewrites can improve recall or silently change intent.

Graphs help when relationships are the missing evidence.

Tool reliability comes from schemas, retries, idempotency, and stop states.

Function schemas are contracts that need compatibility and migrations.

Agent authority should be narrower than model imagination.

Sandboxes bound file, network, process, and secret access.

Autonomy needs terminal states before loops become waste.

State machines make agent progress inspectable and recoverable.

Decomposition should create verifiable subgoals, not vague mini-prompts.

Plans are tentative; orchestration owns durable control flow.

Multiple agents add coordination cost before they add capability.

Routing is a risk and cost policy, not a random fallback list.

Token budgets need request classes, caps, and attribution.

Latency comes from queueing, prefill, decode, tools, and network hops.

Batch and realtime optimize different promises.

Hardware choice follows model size, concurrency, latency, and cost.

Queues need admission control before latency collapse.

Prompts are production artifacts with tests, rollout, and rollback.

System prompts express policy but the harness enforces authority.

Every prompt change needs cases that catch old failures.

Experiments need quality guardrails before engagement metrics.

The packed window is a scarce execution environment.

Compression trades detail for fit and must preserve decision facts.

AI observability joins prompts, tool calls, cost, quality, and feedback.

Incidents need containment, trace review, user impact, and regression fixes.

Privacy controls should minimize data before the model boundary.

Governance is ownership, policy, evidence, and exception handling.

Model cards document intended use, limits, evals, and risks.

Classifiers are policy sensors with false-positive and false-negative cost.

Moderation combines policy, classifiers, human review, and appeals.

Input and output filters see different parts of the risk.

Policy evals translate rules into repeatable cases.

Open weights still need serving, evals, monitoring, and access control.

Deployment location changes privacy, latency, operations, and vendor risk.

Edge inference buys locality but constrains model size and update control.

Rate limits require admission control and fair queues.

Fallbacks need contract compatibility and quality gates.

Fine-tuning quality follows examples, labels, exclusions, and eval slices.

Contamination inflates scores by leaking evaluation data into training.

Drift can come from data, prompts, tools, users, or model upgrades.

Preference data quality depends on task design and reviewer calibration.

Reward models learn preference proxies that need audits.

Tokens, embeddings, self-attention, multi-head attention, and failure modes.

How tokenizers split text and why budgets differ from words and characters.

Lower precision vs smaller student models, with deployment trade-offs and eval slices.

Human preference feedback, principle-guided critique, and alignment failure modes.

Choose broad foundation models, narrow SLMs, or a risk-aware router.

Expand rare cases without teaching shortcuts, leaking data, or faking diversity.

Reasoning budgets, hidden traces, tool checks, and evals for hard model tasks.

Train-time vs test-time scaling, budget forcing, and when extra reasoning pays off.

Reason, act, observe, and stop with bounded tool calls and progress checks.

State, retrieval, consent, decay, and memory precedence for agent systems.

Approval gates, review queues, escalation, undo, and reviewer-load failure modes.

Grounding failures, retrieval versioning, validation, abstention, and no-evidence tests.

Direct user policy bypass versus untrusted content attacks on RAG and tools.

Threat models, adversarial probes, scenario tests, severity, and regression gates.

Attribution, examples, counterfactuals, probes, and explanation contracts by audience.

Rubrics, calibration sets, pairwise judging, bias checks, and release thresholds.

What each benchmark measures and how to translate public scores into product evals.

Human-driven assistance versus bounded autonomous loops with tool verification.

Fast AI-led exploration, production promotion gates, and ownership failure modes.

Instruction-only versus example-shaped prompting, token cost, shortcuts, and eval slices.

Text, image, audio, and video fusion patterns with evidence provenance and uncertainty.

Validate model JSON as versioned contracts before queues, APIs, or workflows consume it.

Stream visible text while buffering tools, gating risky output, and tracing cancellation.

Choose safe reuse rules for exact answers, semantic matches, and repeated prompt prefixes.

Route model calls, protect provider keys, enforce budgets, log traces, and recover failures.

LangGraph, CrewAI, Haystack, LlamaIndex, vLLM, Ollama, FAISS, and vector DBs mapped by stack lane.

Providers, orchestration, vectors, APIs, prompts, pipelines, evals, guards, observability, cloud.

Agentic loops, MCP, gateways, evals, guardrails, observability, and the Bitter Lesson.

Ollama, LangChain, Dify, RAGFlow, and the open-source AI stack mapped by use case.

Dev, research, automation, Claude Code, business, design, and creator skills mapped.

Prompts, automation, RAG, agents, assisted coding, and what to learn first.

From artificial intelligence and machine learning through generative and agentic AI.

Folders, files, and responsibilities for a maintainable Python agent codebase.

What each Claude Code milestone changed: GA, harness, Opus 4.5, Cowork — without timeline myths.

CLAUDE.md, skills, hooks, permissions, and the daily plan→compact loop.

Interactive sessions, print mode, resume flags, permissions, MCP, plugins, background agents, and diagnostics.

Agent→tools (MCP) vs agent→agent registry (A2A) vs REST manifests (ACP).

LLM → RAG → tools → memory → agent → multi-agent → skills/hooks → governance.

Orchestrator LLM, memory, tools, multi-agent protocol, and specialist agents explained.

Managed, open-source, search platforms, and SQL/graph extensions for embeddings.

Three retrieval approaches compared with use cases and trade-offs.

Zero-shot, few-shot, chain-of-thought, and production prompt patterns.

LLM output tracks the window you pack — gather, curate, drop noise, and fix pollution failures.

Micromanage to multi-agent swarms — SDD, YOLO, Ralph loops, and choosing by blast radius.

A capability ladder from vibe coding to orchestration — AGENTS.md, MCP, hooks, sandboxing, swarms.

Classify coding agents by attachment surface—then authorize multi-home products per surface.

Choose an editor, terminal, cloud, or orchestration agent—and place MCP and OpenClaw on the correct layers.

Message vs memory vs machine — when to craft prompts, curate windows, or build loops.

Nine layers from strategy and memory to deployment and observability.

How AI changes repositories, APIs, validation, and microservices in .NET.

Includes vector databases and semantic search with pgvector.

In progress — short orientation on types, interfaces, generics, and utility types.

npm manages packages; npx runs CLIs without permanent installs.

In progress — short orientation on composition, custom hooks, and performance.

In progress — short orientation on App Router, server components, and deploy basics.

In progress — short orientation on tokens, shadcn/ui, and accessibility basics.

Stateless tokens, server sessions, and delegated authorization compared.

Basic Auth, tokens, OAuth, and API keys in production.

Local DB, outbox queue, push with retry, and pull by last_synced_at.

Auth, ORM, testing, logging, platforms, jobs, reporting, and Blazor UI lanes.

RBAC, policies, claims, custom handlers, endpoint and resource authorization.

Scalability, caching, databases, CAP theorem, and URL shortener case study.

Trace one browser request through DNS, TLS, HTTP, origin systems, and rendering.

Per-request time vs completion rate, percentiles, Little's Law, and the saturation knee.

Separate service access, correct behavior, and acknowledged-data survival.

Place session state deliberately and make compute replaceable where possible.

Choose acknowledgment boundaries, deadlines, queues, and duplicate-safe recovery.

Quorum reads/writes, async replication, conflict resolution, and session guarantees.

Hash ring, virtual nodes, and why a scale-out can still stay lopsided.

W/R tuning, sloppy quorums, hinted handoff, and read repair.

Signaling mechanisms, load shedding, and end-to-end propagation.

Hidden SPOFs, real vs disguised redundancy, and correlated failures.

Core-path classification, fallbacks, feature-flag kill switches, and testing degraded mode.

Two different promises, their mechanisms, and a lost-charge failover outage.

When to stop, what state to stop into, and a real fail-open security bug.

Mechanisms, RTO/RPO trade-offs, and a standby that promoted with a stale schema.

Measure the real ratio per table, then match caching or write-optimization to it.

Detect per-shard load imbalance and a noisy-neighbor tenant failure.

The physical latency floor, edge patterns, and a data-residency failure.

Blast radius containment, and a shared config service that broke three regions at once.

Precise definitions, DR tiers, business-impact targets, and a corruption backups almost missed.

Consistency, availability, and partition tolerance — CP vs AP in practice.

Scale up vs scale out — when to use each and how to combine them.

Read replicas, sharding, partitioning, and caching — when to use each.

The three pillars — OpenTelemetry, RED metrics, and distributed tracing.

Every caching layer from browser to Redis — essential for interview answers.

Latency ladder, seven cache types, hit/miss, and eviction policies.

Production path: gateway, DB-per-service, Kafka, resilience, observability, CI/CD on K8s.

Full technology stack — containers, data, messaging, gateways, observability, and cloud.

API Gateway, CQRS, BFF, event-driven, and database per service.

Immutable event logs, read/write separation, and when complexity is justified.

Architecture style decision guide for interview discussions.

L4 throughput vs L7 HTTP routing — how production systems combine both.

TLS, routing, cache, rate limits, static files, and WebSockets at the edge.

Algorithms, Redis implementation, and where to enforce limits at the edge.

Structured decision guide for interview database discussions.

Relational vs document, key-value, and wide-column stores compared.

From commit to production — workflows, Docker builds, and deploy strategies.

Fifteen core commands: setup, daily loop, remotes, branches, and safe undo.

main, develop, feature, release, and hotfix branches — when to use each.

Named volumes, bind mounts, and tmpfs — persistent storage in containers.

User → DNS → Ingress → Service → Pod — the full traffic path step by step.

Container packaging vs orchestration — when to use each in production.

Message broker trade-offs for async system design questions.