The whole modern stack — the machine, the wire, the database, the frameworks, the deploy pipeline, distributed systems, event-driven messaging, the AI layer, the security that guards it, the disaster recovery that saves it, the leadership to ship it all, and the object-design and pattern craft under the code itself — as battle-tested patterns. Every topic has a real example, a plain-English analogy, and the gotcha that bites at 2am.
The patterns a 20-year Postgres veteran reaches for daily — UPSERT, window functions, JSONB, indexing, partitioning, locking, and query tuning.
52 Ruby + 52 Rails topics — from blocks, Enumerable, and metaprogramming to ActiveRecord, N+1, Hotwire, background jobs, auth, and shipping to production.
Containers to a production Kubernetes rolling deploy — Docker, ECR, the full K8s core, EKS internals (IRSA, Karpenter, ALB), and CircleCI pipelines that ship it.
The machine under everything — files, processes, signals, the shell toolbelt (grep/awk/sed), systemd, journalctl, the OOM killer, cgroups. Real commands, real output, the gotcha that pages you.
The wire under everything — IP & CIDR, the TCP handshake, UDP, DNS, TLS, HTTP, proxies, NAT, firewalls, tcpdump, and a debug-in-layers "is it down?" runbook.
Build Model Context Protocol servers — the standard way to give agents tools, data & prompts. Host/client/server, the three primitives, Streamable HTTP, OAuth 2.1 & the trust model (2026 spec). Each topic in plain English with a diagram.
From one tool call to a production LLM agent — foundations, the think-act-observe loop, ReAct, memory, RAG, plus the evals, guardrails, prompt-injection & lethal-trifecta defenses to ship it. Each topic taught five ways.
The machinery for when one machine isn't enough — CAP & consistency, consensus, replication, sharding, quorums, conflict resolution, caching, retries, circuit breakers, bulkheads, and testing distributed systems.
How services talk without falling over — sync vs async, queues vs streams, Kafka, delivery semantics, idempotent consumers, event sourcing, CQRS, the saga & outbox patterns, DLQs, and schema evolution.
From the event loop to a typed production API — V8 & libuv, async/await, streams, modules, the TypeScript type system, generics, runtime validation, testing, performance, and shipping safely.
From JSX to a typed, data-driven feature — components & props, the hooks & rendering model, useEffect deps, state management, data fetching, typing React, performance, error boundaries, testing, and a11y.
The security a full-stack engineer must own — think like an attacker, then XSS, CSRF, CORS, broken access control (IDOR), SQL injection, SSRF, secrets, TLS, and an incident-response runbook. Mapped to the OWASP Top 10.
The plan you hope never to run — RPO/RTO, backups, PITR, WAL archiving, replication, RDS & Aurora, cross-region failover, runbooks, and the game days that get you back when the database goes down.
Design systems at scale and lead the people who build them — estimation, scaling, caching, SLOs & error budgets, tradeoffs & ADRs, migrations, plus code review, mentoring, RFCs, and driving alignment.
OOP taught with the systems you actually ship — payment gateways, ORMs, middleware, notification channels — not Animal/Dog/Car. The four pillars, composition, SOLID, and the judgment to know when not to use objects. Every concept with a real-world "in the wild" example.
The Gang of Four patterns plus the modern ones, taught through real systems — React.createElement, OkHttp builders, Express middleware, HikariCP pools, Kafka pub/sub, circuit breakers — not Shape/Animal demos. Creational, structural, behavioral & architectural, each with when not to reach for it.
The PostgreSQL Disaster Recovery playbook applied end to end to a realistic fintech (NimbusPay) — RPO/RTO by data tier, tiered Aurora + RDS, an immutable cross-account backup vault, five step-by-step runbooks, and the architecture shown three ways: an ASCII topology, an entity (ER) diagram, and a region-failover sequence diagram.
A social feed from one box to a million requests a second — the bottleneck moving to the stateful database, and the ladder (stateless scale-out, read replicas, cache, sharding, queues) that climbs it.
A healthtech leaks 400,000 patient records through one broken-access-control bug. How the attack worked, the incident-response runbook, and the fixes — with an attack sequence diagram and the access model.
A checkout page melts under 8× load because one hidden N+1 turns each request into 51 queries. Finding it, reading the query plan, the eager-load fix, and a capacity plan so it can't recur.
A customer-support agent from a dazzling demo to safe production — the agent loop, tools via MCP, guardrails, the lethal-trifecta / prompt-injection defense, evals as the launch gate, and a staged rollout.
A nightly batch job empties the recommendations table, and every replica copies it. The calm, targeted point-in-time restore from backup — lift one table back, no full failover — and how to design the job so it can't happen.
These aren't sixteen separate subjects — they're one stack, seen from sixteen heights, and the playbooks cross-reference each other on purpose.
A slow endpoint is a Rails N+1 that becomes a Postgres query plan you read with EXPLAIN. That app runs in a container — which is just a Linux process wearing namespaces and a cgroup, so a Kubernetes OOMKilled (exit 137) and a bare-metal OOM killer are the same event. Postgres jsonb reappears as Rails store_accessor; keyset pagination shows up in both the database and find_each; a CIDR block is a CIDR block whether it's a subnet or a VPC. "Connection refused vs timed out" decodes a failed deploy the same way it decodes a broken socket.
And the newest layer sits right on top, now as two playbooks: an AI agent is a loop that calls tools — which it reaches through MCP servers you deploy on EKS, secure like any endpoint, and query against the same Postgres. Build the servers in one playbook, the agents that use them in the other. A prompt-injection defense is least privilege and input validation — the same instincts the Application Security playbook now teaches as its own layer — the perimeter around everything else. The agent isn't a different world; it's the whole stack, with a language model in the loop.
And it keeps going up: those services become a distributed system where a retried request needs idempotency and a queue needs an outbox; the app itself is Node & TypeScript on the server and React in the browser, both catching bugs with the same type system; and above all of it sits the judgment to design at scale and lead the people who build it — estimation, SLOs, tradeoffs, code review, and RFCs.
And underneath all of it is the craft of the code itself: the object-design instincts — encapsulation, composition, SOLID — and the design patterns your frameworks are already built from. That Rails N+1 is a lazy-loading Proxy; the middleware stack is a Chain of Responsibility of Decorators; the circuit breaker guarding a distributed call is one pattern wrapping another; a repository is how the app talks to Postgres without SQL leaking everywhere. Learn the pattern once and you see it everywhere above.
Learn a pattern in one playbook and you'll recognize it in the next — which is exactly how a stack stops being sixteen things you memorized and becomes one thing you understand.
Start at the bottom: files, processes, the shell, and how packets move. Everything above stands on this.
Postgres next — the store your app lives and dies by. Learn to make it fast and correct before building on it.
Ruby & Rails — turn data and requests into a product, with the AR and performance instincts the DB taught you.
Containers, EKS, and CircleCI — take it all to production, on rails you can debug when it pages you.
Expose your systems as MCP servers, then build agents on top — the same stack, with a language model in the loop.
Distributed systems, Node & React with types, then the system-design and leadership judgment to ship it all with a team.