Sign in
Menu

The full map

13 phases. One system. No filler.

Here is the whole route before you pay for step one. You build an return reconciliation and case triage pipeline for Lantern Home Operations, a simulated B2B wholesale distributor with messy real-world data. Each phase adds a part the pipeline needs to run. Python and APIs first. Then models, prompts, retrieval, and agents. Then the part that keeps it honest in production: evaluation, cost, security, and deployment.

13

Phases

57

Units

890

Estimated hours

3 of these 57 units are open today, and the rest are mapped below so you can see the whole route before you spend a cent. Planned units show a title only until they open.

Phase 0~9 HOURS

Orientation & Environment Setup

Setup is where self-taught learners stall, not for lack of talent, but because nobody tells them what "ready" looks like. You finish your first session with a working sandbox and your first graded submission.

You walk away with: Your Docker workspace runs, and you can describe what Lantern Home needs in three sentences. That is the whole bar, and you will clear it tonight.

Its job in the pipeline: The Docker workspace and the first e-commerce order and return fixtures.

  • 0.1
    Meet the client: Lantern HomeFREE SAMPLE

    Follow one customer's message through the support team and see where the two and a half days go.

  • 0.2
    How the curriculum and grading loop workALL ACCESS

    See how automated checks, rubric review, and defence questions produce one verdict. This is the loop behind every grade you will ever get here.

  • 0.3

    One-click Docker environment setupPLANNED

    Install Docker and run Python 3.12, Pytest, and Pydantic inside it.

Phase 1~100 HOURS

Software Engineering Foundations

Later phases are software with one unpredictable part bolted on. If the software underneath wobbles, nothing above it can be trusted, so you learn the software part here, on the intake pipeline itself.

You walk away with: You ship a tested API that reads customer messages and returns clean records. Unglamorous? Completely. Everything else stands on it.

Its job in the pipeline: The intake API that reads and validates customer messages.

  • 1.1

    Python for AI engineeringPLANNED

    Write typed Python and model customer cases with Pydantic, with no more hope-typed dicts.

  • 1.1.1
    Python fundamentals, on Lantern's messagesALL ACCESS

    Read a message file, find the order number and email inside it, and learn how Python runs, remembers and slices along the way.

  • 1.2

    Version control and collaborative git workflowsPLANNED

    Branch, commit, and open pull requests a client's engineer could review.

  • 1.3

    Working with HTTP APIs, webhooks, and rate limitsPLANNED

    Call public APIs and survive retries and rate limits without falling over.

  • 1.4

    Asynchronous programming, event loops and concurrencyPLANNED

    Fetch many records at once with asyncio, and measure the speedup yourself.

  • 1.5

    Testing suites, code quality and pytest fixturesPLANNED

    Cover your parser with pytest, especially the broken input nobody wants to write.

Experienced programmers can take a 20-minute adaptive diagnostic to place straight into Phase 2.

Phase 2~60 HOURS

LLM Fundamentals and Model Behavior

Most brittle prompts come from a wrong mental model. Treat the model as magic and every miss looks like a mystery; learn the mechanism and the misses become predictable; that difference is the whole phase.

You walk away with: You can predict token cost, recall limits, and when to switch models before you spend a cent finding out the hard way.

Its job in the pipeline: The model caller that logs cost and latency per call.

  • 2.1

    How transformer models work practicallyPLANNED

    Explain next-token prediction in plain terms, not "autocomplete on steroids".

  • 2.2

    Tokens, context windows and model degradation patternsPLANNED

    Count tokens and find the exact point where long context starts losing facts.

  • 2.3

    Which model to use and what it costsPLANNED

    Compare three models on the same task for accuracy, speed, and cost, using real numbers, not vendor slides.

  • 2.4

    Calling LLM APIs with retries, backoff, and timeoutsPLANNED

    Build a wrapper with retry and backoff that survives rate limits instead of crashing on them.

Phase 380h build~80 HOURS

Prompt Engineering as a Discipline

Prompts you cannot diff, test, and version in git are incantations, not engineering. Here prompts live in git like code, reviewed, tested, and blamed.

You walk away with: You write prompts that return valid JSON every time, and log failures instead of guessing. Downstream systems will thank you; they cannot read prose.

Its job in the pipeline: The extractor that turns messy notes into valid records.

  • 3.1

    System prompt design and role conditioningPLANNED

    Write system prompts where each line fixes one failure you can point at.

  • 3.2

    Structured outputs and schema-constrained generationPLANNED

    Force valid JSON with Pydantic and handle rejects like a grown-up system.

  • 3.2.1

    Structured extraction with JSON mode and PydanticPLANNED

    Parse messy invoice notes into a ClaimExtraction record.

  • 3.3

    Few-shot exemplars and dynamic in-context retrievalPLANNED

    Test 0, 2, and 5 examples and keep what helps, including the answer "fewer".

  • 3.4

    Prompts as code: versioning, CI testing and regression gatesPLANNED

    Store prompts in git and block merges when accuracy drops. Yes, really block them.

Phase 4~80 HOURS

Retrieval-Augmented Generation (RAG) & Grounding

The model will invent an answer unless you ground it: fluently, confidently, and wrong. You tie every answer to a supplier clause, or you say you cannot tell. There is no third option.

You walk away with: You answer credit-owed questions with a cited clause, or you flag for review. A guess in a finance pipeline is a liability wearing a costume.

Its job in the pipeline: Search over supplier agreements that cites its source.

  • 4.1

    Semantic chunking, metadata extraction and PDF parsingPLANNED

    Parse clean and scanned PDFs, including the tables everyone pretends are easy.

  • 4.2

    Dense vector embeddings and vector databasesPLANNED

    Load clauses into Qdrant and query by meaning plus region (Midwest beverage clauses only, please).

  • 4.3

    Hybrid search and reciprocal rank fusionPLANNED

    Combine keyword and vector search so exact clause numbers actually match.

  • 4.4

    Agentic retrieval loops and graph-based knowledge indicesPLANNED

    Retry with a rewritten query when the context is thin; search, check, search again.

Phase 515% rebate gate~80 HOURS

Tool Use & Agent Orchestration

Agents loop forever and burn budget; this is where most builders stall. Yours will not: step caps, stop rules, and a state log you can replay. Boring? Boring is what ships.

You walk away with: You build an agent that checks the order, checks the rules, and routes the case without exceeding budget. It does the morning triage shift of a human specialist.

Its job in the pipeline: The triage agent with step caps and a full trace.

  • 5.1

    Function calling schemas and structured parameter validationPLANNED

    Define lookup_order, check_prior_refunds, and pass_to_rosa, three tools, zero ambiguity.

  • 5.2

    Single-agent ReAct reasoning loops with hard stop conditionsPLANNED

    Run reason-act-observe loops with a hard iteration cap, because infinity is not a strategy.

  • 5.3

    Multi-agent orchestration and hierarchical routingPLANNED

    Split extraction from routing and add a reviewer check; one agent doing everything degrades, every time.

  • 5.4

    Orchestration frameworks and protocol interoperabilityPLANNED

    Rebuild the loop as a named graph you can draw for a non-engineer.

  • 5.5

    Persistent conversation memory and state compactionPLANNED

    Scope state per case so two customers never mix; cross-contamination is a horror story, not a feature.

Pass the Phase 5 gate within 365 days and you earn a 15% rebate.

Phase 6~60 HOURS

Fine-Tuning & Model Adaptation

Fine-tuning rarely fixes retrieval, but everyone tries it first, usually before prompting has been seriously attempted. You will learn when it pays and how to run LoRA on a small GPU, with evidence instead of vibes.

You walk away with: You decide from evidence whether to prompt, retrieve, or train a LoRA adapter, and "none of the above, prompting won" counts as a correct, defensible answer.

Its job in the pipeline: A small open model tuned on SKU language, only if the numbers justify it.

  • 6.1

    Decision framework: Prompting vs RAG vs Fine-tuningPLANNED

    Write a one-page memo with accuracy numbers for each option, with no vibes allowed.

  • 6.2

    Dataset preparation, data synthesis and formattingPLANNED

    Build a clean 500 to 1000 example set with a held-out split. Quality beats size, every time.

  • 6.3

    Hands-on LoRA and QLoRA parameter-efficient trainingPLANNED

    Train QLoRA on a 7 to 8B model until loss falls without diverging, and know what diverging looks like.

  • 6.4

    Preference optimization for domain tone alignmentPLANNED

    Learn when preference tuning fits and when it does not.

Phase 7How we grade you~70 HOURS

Evaluation & Production Observability

Keel grades you with the method taught here; you learn it by building it. Golden sets, judges, traces. This is the phase that separates people who can demo an agent from people you can trust with a client's data.

You walk away with: You build a golden set, calibrate a judge against your own ratings, and block merges on regressions. It is the same harness that grades you. Now you know exactly how it feels from the inside.

Its job in the pipeline: The eval harness that blocks bad merges.

  • 7.1

    Curating representative golden evaluation datasetsPLANNED

    Write 50 cases including 10 you expect to fail; a golden set with no hard cases measures nothing.

  • 7.2

    Heuristic and LLM-as-judge scoring with quoted evidencePLANNED

    Score with rubrics that quote evidence and match human ratings, then check them against humans anyway.

  • 7.3

    Distributed tracing, token cost accounting and latency telemetryPLANNED

    Trace every call with tokens, cost, and latency. What gets traced gets fixed.

  • 7.4

    CI/CD regression testing for probabilistic modelsPLANNED

    Fail the build when accuracy drops, and watch it catch a bad prompt edit with your own eyes.

Phase 8~50 HOURS

Cost & Performance Engineering

At 4,000 invoices a month, a wasteful call pattern loses money. A system that costs more than the clerk it replaces will not ship, no matter how clever it is.

You walk away with: You price each case, route easy ones to cheap models, and cache repeated prompts. Unit economics you can show a CFO without flinching.

Its job in the pipeline: The router that sends easy cases to cheap models.

  • 8.1

    Token economics, context modeling and ROI calculationsPLANNED

    Model cost per case and show where batching helps, in dollars, not vibes.

  • 8.2

    Dynamic cascading model routersPLANNED

    Route simple cases cheap and escalate hard ones. Biggest-model-always is a rookie tax.

  • 8.3

    Prompt prefix caching, semantic caching and batchingPLANNED

    Cache repeated prefixes and batch the rest. Boring, lucrative, correct.

Phase 9~60 HOURS

Security, Safety & Governance

Your system reads files strangers send, like invoices, emails, and photos with who-knows-what in them. You strip injections, redact PII, and require approval before money moves. Trust is the product here as much as the pipeline.

You walk away with: High payouts wait for a human. Every step lands in an audit log you can replay, days later, for an auditor who is not smiling.

Its job in the pipeline: Guardrails plus an audit log you cannot rewrite.

  • 9.1

    Direct and indirect prompt injection defensePLANNED

    Block direct and indirect injection with delimiters and canaries; assume malice, verify everything.

  • 9.2

    PII redaction, data sanitization and access policiesPLANNED

    Redact PII and limit who sees which invoice. Least privilege, greatest sleep.

  • 9.3

    Human-in-the-loop checkpoints for critical decisionsPLANNED

    Escalate low-confidence or high-value cases to review; confidence thresholds, not gut feelings.

  • 9.4

    Immutable audit logging and regulatory compliance trailsPLANNED

    Keep append-only logs you can export for audit. If it isn't logged, it didn't happen.

Phase 10~60 HOURS

Deployment & Production LLMOps

A demo runs once, on your machine, while you're watching. Production runs at 2 a.m. when the model drifts and nobody is watching. You prepare for that.

You walk away with: You ship a FastAPI service in Docker with health checks and alerts, and a rollback plan you have actually rehearsed.

Its job in the pipeline: The FastAPI service in Docker with health checks.

  • 10.1

    Packaging AI pipelines as REST APIsPLANNED

    Serve FastAPI with streaming responses and clear errors that a client can act on, not stack traces.

  • 10.2

    Ephemeral containerization and sandbox runnersPLANNED

    Cap CPU, memory, and network per run. Your worst tenant should bore you.

  • 10.3

    CI/CD deployment pipelines with evaluation barriersPLANNED

    Deploy only when evals pass. The pipeline has opinions and it enforces them.

  • 10.4

    Production monitoring, drift alerting and on-call runbooksPLANNED

    Alert on latency and drift with a rollback plan, written before you need it, not during.

Phase 11Parallel track from day one~80 HOURS

The Business of AI Engineering

Graduating technically competent but financially broke is the standard failure mode of self-taught engineers. You start this track on day one, not after the technical work, because "I'll figure out clients later" is how later never comes.

You walk away with: You run mock discovery calls, price on value, and send real outreach with a written proposal. Uncomfortable? Good. That is the feeling of the actual skill.

Its job in the pipeline: The proposal packet you can send to a real prospect.

  • 11.1

    Niche and positioningPLANNED

    Pick a niche and write one positioning sentence. One. Sentence.

  • 11.2

    Architectural case studies and portfolio assetsPLANNED

    Write case studies with architecture and measured results, numbers or it didn't happen.

  • 11.3

    Value-based pricing models and ROI calculatorsPLANNED

    Price from client savings with a fixed scope. Hours are not the product; outcomes are.

  • 11.4

    Prospect qualification and outreach workflowsPLANNED

    Find decision makers and follow up on schedule. The fortune is in the follow-up (sorry).

  • 11.5

    Discovery call simulations scored against rubricsPLANNED

    Practice discovery calls scored against a rubric, including the questions you dread.

  • 11.6

    Proposals, contracts and mandatory not-included scopePLANNED

    Draft SOWs that list what is excluded, with milestones and terms. Exclusions are the feature.

  • 11.7

    Retainer conversion, handoff and client communicationPLANNED

    Hand off with docs and convert support into a retainer, the happy ending this whole track points at.

Open from day one. Pair each technical phase with one business unit.

Phase 1215% rebate gate~100 HOURS

Capstone & Cross-Industry Portfolio

One deep build proves you can ship. Three more prove you can repeat it in legal, clinical, and finance settings, because "one vertical" is a project, and "four" is a practice.

You walk away with: Lantern Home's system runs in production, plus three portfolio builds in other industries. Depth and range, on one transcript, all verified.

Its job in the pipeline: The live Lantern Home system plus three portfolio builds.

  • 12.1

    The Capstone: Lantern Home end to end in productionPLANNED

    Connect extraction, retrieval, routing, and audit logs end to end; the whole animal, alive.

  • 12.2

    Cross-Industry Portfolio: Legal brief analyzerPLANNED

    Extract clauses and risks from legal briefs. Same muscles, new sport.

  • 12.3

    Cross-Industry Portfolio: Healthcare clinical notes extractorPLANNED

    Summarize clinical notes with ICD-10 codes and HIPAA redaction, where mistakes matter most.

  • 12.4

    Cross-Industry Portfolio: Financial earnings report synthesizerPLANNED

    Parse 10-K filings into metrics tables and guidance notes. Wall Street prose, meet your parser.

Clear the capstone gate within 365 days and you earn the final 15% rebate.