A 16-week sequel. The cost of every choice. The right tool for the job.

THE AI-AWARE
ARCHITECT.

COACH

DR. MICHAEL LITMAN, Ph.D.

Master Computer Scientist

AI builds what you specify. You decide what's worth building — and what it will cost. Eight weeks on the structures and concurrency that teach you the true price of every choice. Eight more building real internet-aware systems — servers, databases, front ends — choosing the right tool and directing agentic AI to do alone what once took a team.

START WEEK 1 SEE THE SYLLABUS

16

Chapters

14

Projects

8+8

Cost → Systems

5

Stacks: Py · Node · 3 DBs

PHASE 1 · THE COST OF EVERYTHING · WEEKS 1–8

What does it cost?

Arrays, linked lists, stacks, queues, hash tables, trees, graphs, and threads — built by hand and measured, taught as a disciplined accounting of the tradeoff between speed and memory. Python throughout, with the C++/Java memory model in your back pocket. You cannot choose the right tool until you can say what each one costs.

PHASE 2 · THE REAL SYSTEM · WEEKS 9–16

What's the right tool?

HTTP servers in Node.js and FastAPI. Persistence in SQLite, PostgreSQL, and MongoDB. A web front end that's good enough to ship. Every choice driven by the constraints in front of you, every project shaped so an agent can't finish it alone. You own the architecture; the agent builds the pieces.

— SYLLABUS

Phase 1 · The Cost of Everything

Weeks 1–8. Data structures and concurrency, built by hand and measured.

Ch 1 — The Architect's Question

Big-O as the language of cost, measuring time and space, the right-tool thesis, agentic AI, the local toolchain

P1 Measure, Predict, Confirm

Ch 2 — Arrays and the Memory You Can Feel

Contiguous memory, cache locality, amortized growth; Python list internals vs C++ vector / Java ArrayList

P2 Build a Dynamic Array

Ch 3 — Linked Lists and the Cost of Pointers

Singly and doubly linked lists; O(1) splice vs cache-miss pointer-chasing; when linked wins and when it loses

P3 Linked List vs Array Benchmark

Ch 4 — Stacks, Queues, and Deques

Linear ADTs; array-backed vs linked-backed tradeoffs; undo stacks, BFS queues, the call stack

P4 Choose Your Backing Store

Ch 5 — Hash Tables: The Magic and the Fine Print

Hashing, collisions, load factor, average O(1) vs worst case, the space cost; Python dict and set internals

P5 Build a Hash Map

Ch 6 — Trees: When Hierarchy Is the Shape

Binary trees, BSTs, traversals, balance, O(log n); the tree-vs-hash-table tradeoff (order vs raw lookup)

P6 A Searchable Tree

Ch 7 — Graphs and the Shape of Connection

Adjacency list vs matrix as a space/time tradeoff, BFS and DFS, modeling a problem as a graph

P7 Model and Traverse a Network

Ch 8 — Concurrency, Threads, and Midterm Review

Threads vs processes, the Python GIL as a right-tool lesson (I/O- vs CPU-bound), race conditions, locks, Node's event loop as contrast

P8 Concurrent Data Pipeline (MIDTERM)

Phase 2 · The Right Tool, the Real System

Weeks 9–16. Servers, databases, and a front end — choosing under constraint.

Ch 9 — Your First Server: HTTP, Ports, and Node.js

The request/response cycle, ports, HTTP methods and status codes, a minimal Node HTTP + JSON API; the event loop

P9 A JSON API in Node

Ch 10 — APIs, JSON, and FastAPI

REST principles, JSON contracts, FastAPI + Pydantic models as specs; the Node-vs-FastAPI right-tool comparison

P10 The Same API, in FastAPI

Ch 11 — Persistence I — SQLite and the Relational Model

Why databases, tables and rows, SQL CRUD, schema, the relational model; SQLite as the zero-config MVP tool, wired to a backend

P11 Persist It in SQLite

Ch 12 — Persistence II — PostgreSQL and Scaling Up

Client/server databases, connection pooling, migrations, indexes as a space/time tradeoff, transactions and ACID; the SQLite-vs-Postgres decision

P12 Migrate to Postgres, Justify It

Ch 13 — Persistence III — MongoDB and the Document Model

The document store, schema-flexibility as a tradeoff, denormalization; the relational-vs-document decision

P13 Model It in Mongo

Ch 14 — The Front End That's Good Enough

HTML/CSS/JS, fetch() to your own API, forms, rendering data; the MVP front-end philosophy of "good enough"

(no new project — drills + capstone prep)

Ch 15 — Architecting the Whole System

Choosing the stack under constraints (the thesis capstone), where agentic AI accelerates vs where the human must decide, MVP scoping, deployment realities

(no new project — drills + final prep)

Ch 16 — Final Review and Capstone

Capstone — a complete app with a backend server, a chosen-and-justified database, and a reasonable web front end

P14 A Real Internet-Aware Application (FINAL)