Knowledge earned, not memorised.

Six wings, each with a plain job

The names carry the atmosphere. The plain label beside each one says what you will find there, so nobody has to learn the lore to find a lessonquest.

• The Grand Archives Library

  Disciplines, the prerequisite map, every lesson and its sources.

  12 disciplines and 80 lessons.

  Browse the curriculum→

• The Observatory Simulations

  Live models: caches going stale, retrievers ranking, voice pipelines lagging.

  2 simulations are open.

  See what is open→

• The Proving Grounds Trials

  Scenarios and assessments where answers have to be defended.

  Opens later

  Final trials open with the first complete discipline.

• The Forge Code

  Hands-on exercises and projects. Things get built and broken.

  Opens later

  Opens with the first code lessons.

• The Scriptorium Notes

  Personal notes, saved insights, the things worth keeping.

  Opens later

  Opens with notes, when accounts arrive.

• The Hall of Ascension Progress

  Mastery map, ranks or levels, and what still needs work.

  Your progress, kept in this browser.

  See your progress→

How a lesson works

The first four stages are the core path, 8 to 15 minutes. Master is an optional bonus, and Revisit comes back on its own, about a minute a day. Already know a topic? Prove it straight away and move on.

1. I1

   Discover

   The idea, shown as a picture first.

   Core path
2. II2

   Explore

   A live simulation where one control changes one thing.

   Core path
3. III3

   Apply

   A realistic target to meet.

   Core path
4. IV4

   Defend

   Your choice and its cost, argued to the examiner.

   Core path
5. V5

   Master

   Harder variations, as an optional bonus.

   Bonus
6. VI6

   Revisit

   Short questions that come back on a spaced schedule.

   Spaced

Two ways to walk through it

The lessons, the grading and your progress are the same in both. Only the feel changes, and you can switch at any time without losing your place.

Start from a goal

Each route is the smallest set of lessonsquests that reaches the goal. Anything you already know, you can prove and skip.

• Build an evaluated RAG assistant

  A grounded assistant with measured retrieval, judged answers and live monitoring.

  24 lessonsquests, about 4.2 h, 1 open now

  See the route →

• Agents with tools in production

  Function calling to multi-agent systems, with safeguards and evaluation.

  20 lessonsquests, about 3.5 h, 1 open now

  See the route →

• Production backend core

  The system design every LLM app sits on: data, caching, queues, failure.

  14 lessonsquests, about 2.5 h, 1 open now

  See the route →

• Voice agent

  From the voice pipeline to the Voice Architect.

  19 lessonsquests, about 3.4 h, 1 open now

  See the route →

• LLM applications, end to end

  From a model’s first answer to retrieval, agents, evaluation and monitoring: the whole path, with the background each part needs.

  54 lessonsquests, about 9.6 h, 2 open now

  See the route →

The curriculum

12 disciplines and 80 lessonsquests of 8 to 15 minutes, about 14.6 h in all. LessonsQuests open here as they are written, starting with Caching and Cache Invalidation.

• Foundations

  System design fundamentals and trade-offs

  5 lessonsquests, about 0.9 h

  Show the lessonsquests

  1. The request path and where time goes10 min
  2. Throughput, utilisation and queueing10 min, after The request path and where time goes
  3. State, scaling out and load balancing10 min, after The request path and where time goes
  4. Replication and consistency12 min, after State, scaling out and load balancing
  5. Estimation and trade-offs10 min, after Throughput, utilisation and queueing
• Databases

  PostgreSQL, indexing, transactions, concurrency

  6 lessonsquests, about 1.1 h

  Show the lessonsquests

  1. Tables, keys and modelling10 min, after The request path and where time goes
  2. Indexes and query plans12 min, after Tables, keys and modelling
  3. Transactions and the write-ahead log10 min, after Tables, keys and modelling
  4. MVCC and isolation anomalies12 min, after Transactions and the write-ahead log
  5. Locks, contention and deadlocks10 min, after MVCC and isolation anomalies
  6. Replicas, pooling and partitioning12 min, after Transactions and the write-ahead log; Replication and consistency
• Caching

  TTL, invalidation, consistency, Redis and Valkey

  6 lessonsquests, about 1.1 h · one open now

  Show the lessonsquests

  1. The Stale Cache12 min
  2. Cache patterns and where caches live10 min, after The Stale Cache: TTL and invalidation
  3. Valkey and Redis in practice12 min, after Cache patterns and where caches live
  4. Hit ratio, working sets and sizing10 min, after Valkey and Redis in practice; Estimation and trade-offs
  5. Races and stampedes12 min, after The Stale Cache: TTL and invalidation
  6. HTTP, CDN and prompt caching12 min, after Cache patterns and where caches live
• Queues and streams

  APIs, background jobs, RabbitMQ, Kafka, stream processing

  6 lessonsquests, about 1.1 h

  Show the lessonsquests

  1. APIs: resources, idempotency, pagination10 min, after The request path and where time goes
  2. Background jobs, retries and rate limits10 min, after APIs: resources, idempotency, pagination; Throughput, utilisation and queueing
  3. Delivery guarantees and the outbox12 min, after Background jobs, retries and rate limits; Transactions and the write-ahead log
  4. RabbitMQ: exchanges, acks, quorum queues10 min, after Background jobs, retries and rate limits
  5. Kafka: logs, partitions, consumer groups12 min, after Background jobs, retries and rate limits
  6. Stream processing, windows and back-pressure12 min, after RabbitMQ: exchanges, acks, quorum queues or Kafka: logs, partitions, consumer groups; Throughput, utilisation and queueing
• Reliability

  Failure handling, observability, SLOs, scaling

  6 lessonsquests, about 1.1 h

  Show the lessonsquests

  1. Timeouts, retries and retry storms10 min, after Throughput, utilisation and queueing; APIs: resources, idempotency, pagination
  2. Circuit breakers, bulkheads and fallbacks10 min, after Timeouts, retries and retry storms
  3. Observability: logs, metrics, traces12 min, after The request path and where time goes
  4. SLIs, SLOs and error budgets10 min, after Observability: logs, metrics, traces
  5. Scaling patterns, hot keys and load tests12 min, after State, scaling out and load balancing; Replicas, pooling and partitioning; Hit ratio, working sets and sizing
  6. Incidents and postmortems10 min, after Circuit breakers, bulkheads and fallbacks; SLIs, SLOs and error budgets
• Working with LLMs

  Calling models, tokens and cost, prompts, structured output, context

  6 lessonsquests, about 1 h · one open now

  Show the lessonsquests

  1. What the Model Cannot Know8 min
  2. Calling a model: messages, tokens and cost10 min, after What an LLM is, and what it cannot know
  3. Prompts that ground answers10 min, after Calling a model: messages, tokens and cost
  4. Structured output and validation10 min, after Calling a model: messages, tokens and cost
  5. Sampling and choosing a model10 min, after Calling a model: messages, tokens and cost
  6. Context engineering10 min, after Prompts that ground answers
• Search and RAG

  Lexical search, embeddings, vector databases, ingestion, chunking

  9 lessonsquests, about 1.6 h

  Show the lessonsquests

  1. The RAG pipeline10 min, after Prompts that ground answers
  2. Lexical search and BM2512 min, after The RAG pipeline
  3. Ingestion apart from querying10 min, after Lexical search and BM25
  4. Embeddings and similarity12 min, after The RAG pipeline
  5. Vector search, exact and approximate12 min, after Embeddings and similarity
  6. Vectors in PostgreSQL10 min, after Vector search, exact and approximate; Indexes and query plans
  7. Chunking long documents12 min, after The RAG pipeline
  8. Shipping embeddings10 min, after Embeddings and similarity
  9. Freshness, metadata and live retrieval10 min, after Ingestion apart from querying
• Retrieval quality

  Ground truth, metrics, tuning, hybrid search, reranking, thresholds

  8 lessonsquests, about 1.6 h

  Show the lessonsquests

  1. Ground truth for search10 min, after Lexical search and BM25; Structured output and validation
  2. Hit rate, MRR and other metrics12 min, after Ground truth for search
  3. Tuning search without fooling yourself10 min, after Hit rate, MRR and other metrics
  4. Hybrid search and rank fusion12 min, after Hit rate, MRR and other metrics; Vector search, exact and approximate
  5. Reranking10 min, after Hybrid search and rank fusion
  6. Query rewriting, thresholds and the honest no-answer10 min, after Hybrid search and rank fusion; Prompts that ground answers
  7. The Retrieval Trial15 min, after Tuning search without fooling yourself; Reranking; Query rewriting, thresholds and the honest no-answer
  8. The Legal Reference15 min, after The Retrieval Trial; Freshness, metadata and live retrieval; Chunking long documents
• Agents

  Function calling, the agent loop, MCP, memory, orchestration, safeguards

  9 lessonsquests, about 1.7 h

  Show the lessonsquests

  1. Function calling12 min, after Structured output and validation; The RAG pipeline
  2. The agent loop and its budgets12 min, after Function calling
  3. When not to use an agent8 min, after The agent loop and its budgets
  4. Frameworks and what they hide10 min, after The agent loop and its budgets
  5. MCP: tools over a protocol12 min, after Function calling; APIs: resources, idempotency, pagination
  6. Memory and context windows12 min, after The agent loop and its budgets; Embeddings and similarity
  7. Multi-agent systems and orchestration12 min, after When not to use an agent; Background jobs, retries and rate limits
  8. Safeguards: guardrails, injection, permissions12 min, after The agent loop and its budgets
  9. Evaluating agents12 min, after The agent loop and its budgets; LLM as a judge
• Evaluation and monitoring

  LLM as a judge, logging, feedback, dashboards, ingestion pipelines

  7 lessonsquests, about 1.2 h

  Show the lessonsquests

  1. Offline and online evaluation8 min, after The RAG pipeline
  2. LLM as a judge12 min, after Offline and online evaluation; Structured output and validation; Ground truth for search
  3. Comparing prompts and models10 min, after LLM as a judge; Sampling and choosing a model
  4. Logging every LLM call10 min, after Calling a model: messages, tokens and cost; Tables, keys and modelling
  5. Feedback and online judges10 min, after Logging every LLM call; LLM as a judge
  6. Dashboards and traces for LLM apps12 min, after Logging every LLM call; Observability: logs, metrics, traces
  7. Ingestion pipelines12 min, after Ingestion apart from querying; Background jobs, retries and rate limits
• Voice agents

  Streaming, latency budgets, endpointing, provider fallbacks

  5 lessonsquests, about 1 h

  Show the lessonsquests

  1. The voice pipeline10 min, after Function calling; The request path and where time goes
  2. Streaming end to end12 min, after The voice pipeline; Throughput, utilisation and queueing
  3. Latency budgets, endpointing and barge-in12 min, after Streaming end to end
  4. Provider fallbacks and failure10 min, after Latency budgets, endpointing and barge-in; Circuit breakers, bulkheads and fallbacks
  5. The Voice Architect15 min, after Provider fallbacks and failure; Memory and context windows
• Shipping

  Testing, containers, CI/CD, AI-assisted engineering, LLM rollouts

  7 lessonsquests, about 1.3 h

  Show the lessonsquests

  1. Testing strategy10 min, after The request path and where time goes
  2. Configuration, secrets and containers10 min, after Testing strategy
  3. From notebook to service10 min, after Configuration, secrets and containers; The RAG pipeline
  4. CI/CD, migrations and rollbacks12 min, after Testing strategy; Transactions and the write-ahead log
  5. Progressive delivery and version skew10 min, after CI/CD, migrations and rollbacks
  6. AI-assisted engineering12 min, after Testing strategy; The agent loop and its budgets
  7. Shipping an LLM feature12 min, after Progressive delivery and version skew; Dashboards and traces for LLM apps; Evaluating agents