From tensor to tenant -
become the AI engineer production teams actually need.
A production-oriented learning path that turns you into an AI / software engineer who can build, evaluate, deploy, and operate ML and LLM systems - and pass the interviews that get you hired to do it.
One progression, six stages
Every phase of the course pushes you one step along the pipeline - from the math inside a tensor, all the way to operating a multi-tenant AI platform where real users, real budgets and real SLAs live.
Most AI tutorials teach you to call an API. This one builds the person who ships the platform.
The market is flooded with model wrappers and cookie-cutter bootcamps. This course is the opposite: a production-oriented apprenticeship that grounds every abstraction in mathematics, then pushes you through the systems that make ML and LLM products actually work in the real world - and through the interviews that prove it.
- Production orientation
- Each week ships a useful artifact: code, a benchmark, a design, or a retrospective.
- Evidence-based completion
- Progress is proven by artifacts, not attendance. Portfolios at Weeks 30, 69 and 108.
- Mathematics first
- 100 modules across 10 tracks build the reasoning beneath ML, inference and distributed systems.
- Interview mastery
- A continuous 176-item roadmap spanning system design, coding and behavioral preparation.
- Staff-level capstones
- Trace forensics with Mo's algorithm, tree forensics with DSU, and an enterprise AI gateway.
- Tenant-aware engineering
- Concurrency, isolation and fairness are part of the first primitives, not a demo-day afterthought.
Three stackable programs
Stop at any checkpoint with a publishable release, or continue to the full 108 weeks.
Math, numerical routines, and experimentation toolkit
Tested primitives, system designs, MLOps tools, and postmortem
LLM/RAG work, inference benchmark, platform layer, and capstone
Ten phases across the 108 weeks
Orientation, tooling, and diagnostics
Mathematical foundations I: linear algebra & numerical methods
Mathematical foundations II: calculus, autodiff, probability, statistics
Engineering micro-projects and applied ML primitives
System design and distributed systems fundamentals
ML lifecycle, experimentation, and MLOps
LLM training, RAG, agents, and evaluation
LLM inference and performance engineering
Production AI platform engineering
Capstone, portfolio, and interview readiness
Three lanes run alongside the weekly spine
A weekly algorithmic drill with Core, Supporting, Archive and Boss-fight tiers, mapped across all 108 weeks. Friday is for fluency.
Weeks 46–57: foundations, distributed patterns, technology labs, case studies, and OOD/LLD - the canonical design lane of the course.
A timed problem-solving lane with a 548-slot tracker and optional Standard/Auror completion paths. 3–5 problems per week, timer on.
From no-code prototypes to autonomous UI agents
An 18-module agents track inside the course: LangChain, LangGraph, AutoGen, CrewAI, Model Context Protocol, agentic design patterns, DSPy, Kùzu graph RAG - capped by Project Manus, an agent that autonomously operates a real browser and terminal.
Foundations → prompting → RAG → agents from scratch → MCP → three orchestration frameworks → agentic patterns → advanced RAG → DSPy → Kùzu. Every framework grounded in evidence-first, tenant-aware engineering.
You don't take notes - you become someone else
Sixteen mandalas turn the course into an identity ladder: each 48-day cycle ends with a capability you can prove.
Build a reliable learning system
Disciplined learner
They replace vague plans to study AI with a working weekly process.
Learn the geometry beneath intelligence
Linear-algebra thinker
Embeddings, attention and matrix models become geometric objects. The learner can reason about them.
Numerical computation and differentiation
Numerical programmer
They learn to ask whether an algorithm is mathematically correct and numerically sane.
Probability, autodiff and statistical inference
Statistical reasoner
They can explain why training and evaluation procedures work instead of treating them as imports.
Experimentation meets retrieval
Retrieval and experimentation builder
They can now build the primitives behind search, experimentation and traffic control.
Production reliability and measurable AI
Reliability-minded engineer
They stop thinking only about model output and start thinking about trust, failure, observability and operational behavior.
Distributed primitives and design reasoning
Distributed-systems implementer
They can move from implementing one process to reasoning about many machines.
Classic distributed systems
System designer
They stop naming technologies and start defending architecture.
From system design to ML product science
ML systems practitioner
A production ML system begins with a decision and a dataset, rather than model training alone.
Build a mature experimentation platform
Experimentation engineer
They can tell when a metric moved and when the evidence supports changing the product.
Train, align and retrieve with LLMs
LLM training and retrieval engineer
They understand the whole upstream and retrieval lifecycle rather than treating the LLM as a remote magic endpoint.
RAG, agents and inference foundations
RAG and agent engineer
They can build an agent and explain where its latency, errors, context and cost come from.
Become an inference systems engineer
Inference performance engineer
They can diagnose inference rather than simply complain that it is slow.
Advanced serving and reliable routing
Serving and routing engineer
They can optimize a model and a multi-provider inference service.
Build the enterprise AI platform
Multi-tenant AI platform engineer
This is where “tensor” finally becomes “tenant.”
Graduation - portfolio, capstone and interview readiness
Portfolio-backed Staff AI Systems candidate
They no longer need to tell someone they “know AI systems.” They can provide the repository, traces, benchmarks, design documents and failure tests.
Progress is gated, not assumed
Ten blocking checkpoints. A failed gate pauses new content until its remediation plan is complete and the missing evidence is submitted.
Course repo · weekly tracker · Dockerized service · diagnostic report
Explain eigenvalues, SVD, norms, condition numbers; implement basic numerical routines
Derive basic gradients; explain MLE/MAP; implement hypothesis tests + bootstrap CIs; explain power/MDE
Completed all engineering primitives (retrieval, rate limiting, caching, chunking, PII, metrics, resilience, sketches, routing)
Completed system design case studies with requirements, API, data model, scaling, trade-offs, failure modes
A/B analysis tool, bootstrap tool, SRM detector, feature flag engine, experiment assignment, monitoring plan
RAG retrieval pipeline, retrieval evaluation report, prompt system, memory system, agent prototype
Deployed vLLM or SGLang, benchmark methodology, observability dashboard, quantization report, speculative decoding report, inference cost model
Working production AI platform: router, quotas, tracing, logging, idempotency, work queue, model registry, cost attribution, safety filters
Completed capstone, published portfolio, passed mock interviews, behavioral stories, 30-day job-search plan
Three staff-level finale paths
Multi-Tenant LLM Trace Forensics with Mo's algorithm - exact batch queries over immutable trace segments.
Agent Execution Forensics with Euler Tour + DSU on Tree - subtree analytics over 50k-node agent trees.
An OpenRouter-inspired enterprise multi-model AI gateway: routing, tenancy, accounting and reliability.
Ready to run the arc?
To start, use the course's cookiecutter: one command scaffolds a complete learner repository with all 108 weekly journals stamped with your start date, the phase folders, engineering primitives, the Darbar tracker, milestone gates, portfolio checklists, and helper scripts.
cookiecutter gh:sethuiyer/tensor-to-tenant