Cross-Domain Connections
The four domains are not separate courses. The defining feature of Engineer Atlas is understanding how a fundamental computer-science concept becomes a real production system — and these are the explicit links.
Learning journeys
Follow one idea from fundamentals to production. Each step opens the lesson in its own domain.
Hash Tables → Database Hash Join → Consistent Hashing → Distributed Cache
One idea — hash a key to find where it lives — from an array of buckets to a ring of servers.
Queues → Message Queues → Sync vs Async → Event-Driven Architecture
From FIFO in memory to a broker between processes to a system that announces facts instead of making calls.
Vector Search → Vector Storage → RAG → Agent + RAG
Similarity over embeddings becomes retrieval infrastructure, then the memory an agent reasons over.
ACID → Distributed Consistency → Distributed Transactions → Sagas
What one database guarantees, what replication weakens, what services lose, and how a saga gets part of it back.
B-Trees → Indexes → Scaling a Database → Scale This System
From a balanced tree on disk to the first rung of every scaling ladder to the whole system built one problem at a time.
Tool Calling → Tool Errors & Retries → Idempotency → Circuit Breaker
An agent calling a tool is a service calling a dependency: the same timeouts, the same retries, the same protection.
DSA → Architecture
Data structures and algorithms that turn into production mechanisms.
Hash Table→Consistent HashingA hash table maps keys to buckets; put the buckets on a ring of servers and let a node join without remapping every key, and you have a distributed cache.
Queue→Message QueuesFIFO with enqueue and dequeue becomes a broker once the producer and consumer are different processes that fail independently — which adds acks, visibility timeouts and dead letters.
Directed Graph→MicroservicesA service dependency graph is a directed graph; cycles in it are the synchronous call loops that turn one slow service into an outage.
DAG (Directed Acyclic Graph)→Saga PatternA saga is a DAG of steps with a compensating edge for each; the order of the steps decides which failures can be undone.
Topological Sort→Background Jobs and WorkersJobs with dependencies (transcode before thumbnail before publish) are scheduled in topological order, and a cycle means a workflow that can never finish.
Sliding Window (Fixed Size)→Rate LimitingThe fixed-window counter over a stream is exactly a rate limiter, and its boundary problem (2× through at the edge) is why sliding windows and token buckets exist.
LRU Cache→Caching ArchitectureThe eviction policy you implemented with a hash map and a linked list is what Redis runs at scale, with TTLs, stampedes and hot keys layered on top.
Bloom Filter→CDN ArchitectureAn edge can answer "is this object definitely not cached anywhere near me" in one probabilistic check and skip a round trip to the origin for misses.
Priority Queue→Background Jobs and WorkersA heap ordered by priority becomes a job scheduler once the consumers are worker processes — and shows why one queue with priority fields starves the low end under load.
Binary Search→Consistent HashingFinding the first node clockwise on the ring is a binary search over the sorted node positions, which is why lookups stay O(log N) with thousands of virtual nodes.
Databases → Architecture
Database mechanisms that become system-level architecture.
Replication and Read Scaling→Horizontal vs Vertical ScalingRead replicas are how a database scales horizontally for reads while writes stay on one primary — the asymmetry that shapes every scaling ladder.
Transactions and ACID→Distributed TransactionsACID inside one database is what you lose the moment a write spans two services, and everything in sagas and outboxes is an attempt to get part of it back.
Partitioning and Sharding→Consistent HashingPartitioning by key is the database form of the ring; consistent hashing is how the partitions move when nodes join and leave without a full reshuffle.
Why Is This Query Slow? Indexes→Scale This SystemThe first rung of the scaling ladder is usually an index, not a cache or a shard — performance architecture starts with the query plan.
Caching Patterns→Caching ArchitectureCache-aside, write-through and write-behind are the per-key patterns; the architecture lesson places them across browser, CDN, application and Redis layers.
Distributed Consistency: CAP, Quorums, Consensus→CAP and Distributed SystemsQuorums and linearizability inside a replicated database are the same choices a whole system makes during a partition, with the same W + R > N arithmetic.
Redis: Data Structures, Not a Cache→Stateless vs Stateful ServicesSessions, counters and presence in Redis are what let an application server hold no state, so any instance can serve any request.
Agentic Engineering → Architecture
AI-system concerns that are ordinary distributed-systems concerns underneath.
Tool Calling Basics→API Architecture: REST, GraphQL, RPC, gRPC, WebSockets, WebhooksEvery tool an agent calls is an external API with a contract, a timeout and a failure mode — the same decisions as integrating any service.
The Agent Loop→Background Jobs and WorkersAn agent loop that runs for minutes is a background job with retries, timeouts, progress reporting and a budget, not a request handler.
Vector Storage→Scale This SystemRetrieval infrastructure scales like any read-heavy system: index, cache the hot queries, replicate, then partition the vector store.
Evaluating Agents: Testing Probabilistic Systems→Availability, SLOs and Error BudgetsAn eval suite defines an SLI for model behaviour; an error budget on it is how AI reliability becomes a release policy instead of an opinion.
Idempotency→IdempotencyA tool call retried after a timeout is the same problem as a payment retried after a timeout, and the fix is the same key stored with the result.
Tracing Agents→Distributed TracingA trace of an agent run — spans per model call and tool call under one trace id — is a distributed trace, and it answers the same question: where did the time go.
Reliability Overview: The Seven Failure Scenarios→Reliability PatternsTimeouts, retries with budgets, fallbacks and breakers around a model provider are the classic reliability patterns applied to a slow, expensive, occasionally down dependency.
Budgets, Limits and Termination→Rate LimitingA token budget per run and a rate limit per tenant are the same mechanism: a bounded counter that turns unbounded demand into a controlled refusal.