LEARNING PATHS · ONE ROUTE AT A TIME

Start with foundations. Keep one clear next step.

You do not need to choose among all 43 courses. If you are new, your route is already decided: begin with Computing & Programming Foundations and open a specialty only after you can prove the entry checkpoint.

Open Foundations →See the complete beginner route
HOW TO STUDY

A path is a dependency map, not a race.

Use the same four-step loop in every chapter. Advance only when you can produce the checkpoint evidence without copying the lesson.

  1. 01Orient and predict.

    Name the question, connect it to what you already know, and predict one observable result before revealing it.

  2. 02Read and define.

    Explain each new term in plain language and trace why each step follows from the previous one.

  3. 03Reproduce and change.

    Run the example, verify its evidence, then change exactly one condition and explain the difference.

  4. 04Practice and retrieve.

    Close the lesson, solve the checkpoint without copying, and return only to the first missing idea.

YOUR DEFAULT ROUTE

New to programming? Path 01 is already chosen.

Finish one stage, prove its checkpoint, and continue. The seven specialty routes below stay closed until you deliberately ask to compare them.

PATH 01 · FIRST PRINCIPLES

Absolute beginner to independent builder

For someone who needs the words “file,” “process,” “function,” “test,” and “database” explained before choosing a specialty.

Start here if

You have never written a program, or you have followed tutorials but cannot yet explain what runs, where data lives, or how to debug one failure.

  1. 1
    Build the computer modelComputing & Programming Foundations

    Files, terminals, processes, networks, program structure, testing, Git, and a complete project.

  2. 2
    Learn one readable languagePython

    Values, decisions, functions, collections, files, objects, errors, tests, typing, and maintainable packages.

  3. 3
    Learn how to prove behaviorTesting & Quality Engineering

    Oracles, partitions, state machines, properties, real boundaries, concurrency, mutations, diagnosis, and recovery evidence.

  4. 4
    Reason about algorithmsData Structures & Algorithms

    Complexity, invariants, collections, trees, graphs, dynamic programming, greedy proofs, and string search.

  5. 5
    Store and query factsSQL Fundamentals

    Filtering, joins, aggregation, constraints, transactions, and query plans.

  6. 6
    Connect the engineering lifecycleSoftware Engineering

    Requirements, architecture, testing, refactoring, security, delivery, ownership, and reliability.

Ready to choose a specialty when

You can create a project from a clean directory, explain its inputs and state, write and test a function, query stored data, diagnose one seeded defect, and restore a known version.

FIRST TRANSFER PROJECTBuild the Data-contract inspector →
PATH 02 · WEBFrontend Web engineeringOpen after you can navigate files, run commands, explain a function and HTTP request, and use version control.

For builders who want accessible interfaces that remain correct through state, network, security, performance, and deployment changes.

Entry checkpoint

You can navigate files, run commands, explain a function and HTTP request, and use version control. Otherwise begin with Path 01 through Foundations.

  1. 1
    Own the browser foundations

    HTML Structure & Accessibility → CSS Layout & Design Systems

    Start with semantic content, forms, keyboard behavior, cascade, layout, typography, and responsive structure.

  2. 2
    Program the platformJavaScript

    Language behavior, DOM, events, asynchronous work, modules, tests, security, and performance.

  3. 3
    Model application statesTypeScript

    Types, narrowing, runtime validation, generics, modules, tooling, testing, and architecture.

  4. 4
    Build with a production frameworkReact & Next.js

    Rendering, state, server boundaries, caching, mutations, accessibility, security, and recovery.

  5. 5
    Integrate the complete Web systemWeb Application Engineering

    Routing, offline behavior, real-time updates, authentication, testing, delivery, and user-centered performance.

Path proof

A user can complete the critical journey by keyboard at mobile and desktop widths; state survives the intended lifecycle; network races and failures are tested; a bad release rolls back without losing user data.

CAPSTONE BRIEFBuild the Browser study tracker →
PATH 03 · SERVICESBackend and API engineeringOpen after you can write tested functions, use Git, explain HTTP, and query a table.

For builders who want to own domain rules, transactions, identity, distributed work, service capacity, and operational recovery.

Entry checkpoint

You can write tested functions, use Git, explain HTTP, and query a table. Take Foundations and SQL first if any boundary is missing.

  1. 1
    Choose one service language

    Python, Go, Java, or C# & .NET

    Finish one language course deeply. Add another only for a real platform requirement.

  2. 2
    Own durable state

    SQL Fundamentals → Database Engineering

    Model invariants, joins, indexes, concurrency, migration, least privilege, backup, and restore.

  3. 3
    Engineer the application boundaryBackend & API Engineering

    Domain design, HTTP contracts, authorization, transactions, queues, workflows, observability, and overload.

  4. 4
    Operate the process and request pathLinux, Networking & SRE

    Processes, files, DNS, routing, sockets, TLS, proxies, limits, SLOs, incidents, and recovery.

  5. 5
    Automate deliveryDevOps Engineering

    Services, artifacts, infrastructure, containers, delivery gates, observability, capacity, and disaster recovery.

Path proof

Concurrent requests preserve database invariants, every endpoint authorizes the exact resource, retries do not duplicate effects, overload is bounded, and a second operator can release, roll back, restore, and reconcile.

CAPSTONE BRIEFBuild the Transactional enrollment ledger →
PATH 04 · DATA SYSTEMSData engineeringOpen after you can write tested Python, use SQL joins and aggregation, and explain files, timestamps, and transactions.

For builders who want every analytical value to remain traceable through ingestion, replay, modeling, streaming, governance, and recovery.

Entry checkpoint

You can write Python functions and tests, use SQL joins and aggregation, and explain files, processes, timestamps, and database transactions.

  1. 1
    Prepare language and query fluency

    Python → SQL Fundamentals

    Build deterministic transformations and reason about row grain before adding infrastructure.

  2. 2
    Understand storage authorityDatabase Engineering

    Constraints, transactions, indexes, replication, partitioning, migration, access, backup, and restore.

  3. 3
    Build the complete data pathData Engineering

    Contracts, replay, analytical models, columnar layout, orchestration, quality, CDC, streaming, lakehouse tables, lineage, and incidents.

  4. 4
    Operate under real resourcesLinux, Networking & SRE

    Learn the process, network, capacity, service-objective, and recovery evidence beneath pipeline tools.

  5. 5
    Continue into data products when neededData & AI Engineering

    Add statistics, evaluation, features, models, monitoring, privacy, and human decision boundaries.

Path proof

Repeated input has predictable effects; source, accepted, quarantined, and output facts reconcile; joins preserve grain; late data and deletion propagate; a historical repair stays bounded and recoverable.

CAPSTONE BRIEFBuild the Replayable data-quality pipeline →
PATH 05 · TRUSTWORTHY AIAI, LLM, and RAG systemsOpen after you are comfortable with Python, arrays, functions, SQL, tests, and evaluation data boundaries.

For builders who want to connect mathematical intuition, clean data, honest evaluation, evidence retrieval, model behavior, safety, and production controls.

Entry checkpoint

You can program comfortably in Python, reason about arrays and functions, query data, write tests, and explain train, validation, and test boundaries.

  1. 1
    Build mathematical intuitionAI Mathematics learning path

    Begin with Mathematics for AI, then take the focused linear algebra, probability, calculus, information, or discrete branch your project exposes.

  2. 2
    Implement trustworthy model pipelinesPython for AI & Machine Learning

    Numerical work, leakage-safe splits, baselines, evaluation, RAG foundations, deployment, and monitoring.

  3. 3
    Own the evidence substrateData Engineering

    Version data contracts, pipelines, quality, history, lineage, access, cost, and recovery.

  4. 4
    Engineer grounded language systemsLLM & RAG Systems

    Tokens, embeddings, corpus lifecycle, retrieval evaluation, reranking, citations, abstention, security, cost, and rollback.

  5. 5
    Add bounded action only when requiredAI Agent Engineering

    Tool contracts, memory, orchestration, human approval, evaluation, authority, and incident recovery.

Path proof

Every model release compares with a baseline on frozen cases; every factual answer maps to authorized evidence or abstains; security invariants cannot be averaged away; model, prompt, corpus, and policy roll back independently.

CAPSTONE BRIEFBuild the Tenant-safe RAG release gate →
PATH 06 · INFRASTRUCTURESystems, Linux, and cloud reliabilityOpen after Foundations; the route teaches command-line reasoning before machine-near code and host operations.

For builders who want to understand the layers beneath runtimes and operate services through real resource, network, deployment, and failure boundaries.

Entry checkpoint

You completed Foundations and can create a plain-text file, run one terminal command, compare exact output, and preserve local Git evidence. No shell language, C syntax, Linux administration, container, cloud, or production experience is assumed.

  1. 1
    Understand command execution preciselyShell & Command-Line Engineering

    Words, quoting, parameters, streams, files, processes, CLI contracts, testing, bounded authority, and recovery.

  2. 2
    Learn machine-near programmingC Language

    Compilation, values, arrays, pointers, memory, files, concurrency, portability, and secure native programs.

  3. 3
    Connect runtime to operating systemSystems Engineering

    Compilation, virtual memory, processes, I/O, networking, atomics, security boundaries, profiling, and fuzzing.

  4. 4
    Operate the complete request pathLinux, Networking & SRE

    Linux lifecycle, descriptors, shell safety, DNS, routing, sockets, HTTP/TLS, capacity, SLOs, and incidents.

  5. 5
    Automate reproducible operationsDevOps Engineering

    Artifacts, configuration, infrastructure code, containers, delivery, security, observability, and recovery.

  6. 6
    Scale through reconciliationCloud Native & Kubernetes Engineering

    Controllers, scheduling, networking, storage, policy, rollouts, autoscaling, upgrades, cost, and disaster recovery.

Path proof

You can trace one request from DNS to process and state, identify the first saturated resource, contain a bad release, survive a node or dependency failure, and restore user service from retained artifacts and data.

CAPSTONE BRIEFBuild the Local request-path observatory →
PATH 07 · DEFENSECybersecurity and application securityOpen after you can explain a Web request, API, transaction, process, dependency, deployment, and test.

For builders who want security grounded in system behavior, application identity, data lifecycle, supply chains, detection, and rehearsed response.

Entry checkpoint

You can explain a Web request, API, database transaction, operating-system process, dependency, deployment, and test. Security study without those models becomes a checklist.

  1. 1
    Understand application boundaries

    Web Application Engineering → Backend & API Engineering

    Learn browsers, sessions, inputs, outputs, domain rules, transactions, queues, and distributed failure.

  2. 2
    Understand host and network authorityLinux, Networking & SRE

    Processes, files, permissions, names, packet paths, TLS, proxies, evidence, and operational recovery.

  3. 3
    Build the security programCybersecurity & Application Security

    Threat modeling, identity, authorization, injection, cryptography, dependencies, cloud controls, detection, and incident response.

  4. 4
    Harden delivery and infrastructure

    DevOps Engineering → Cloud Native & Kubernetes

    Protect artifacts, credentials, infrastructure changes, workload identity, policies, secrets, upgrades, and recovery.

Path proof

A threat model connects assets and actors to enforced controls; authorization is tested at the resource; secrets never enter artifacts or logs; an injected attack is detected and contained; restore and credential rotation are rehearsed.

CAPSTONE BRIEFBuild the Secure document service →
PATH 08 · PRODUCT APPLICATIONSMobile and desktop product engineeringOpen after you can write tested functions and object models, use Git, explain asynchronous HTTP, and persist structured data.

For builders who want installable products that preserve state across lifecycle, offline work, synchronization, accessibility, migration, packaging, and release.

Entry checkpoint

You can write tested functions and object models, use Git, explain asynchronous work and HTTP, and query or persist structured data.

  1. 1
    Choose one platform language

    Kotlin for Android or multiplatform, Swift for Apple platforms, or C# & .NET for a .NET desktop route.

    Finish the language’s state, async, testing, persistence, and tooling chapters before branching.

  2. 2
    Engineer mobile lifecycle when applicableMobile Engineering

    Lifecycle-safe state, declarative UI, offline synchronization, permissions, accessibility, migrations, deep links, observability, and stores.

  3. 3
    Engineer desktop lifecycle when applicableDesktop Application Engineering

    Responsive state, undo, persistence, synchronization, plugins, diagnostics, accessibility, packaging, and secure updates.

  4. 4
    Strengthen the service boundary

    Backend & API Engineering and Database Engineering as your product needs them.

    Own synchronization identity, conflict, authorization, migrations, offline replay, and recoverable server state.

Path proof

The product survives restart, rotation or window recreation, offline mutation, conflicting synchronization, schema migration, permission denial, accessibility review, package installation, bad update, and state recovery without hidden developer state.

CAPSTONE CHAPTERBuild the offline course application →
START NOW

Begin at the first idea you cannot yet explain and prove.

If you are unsure, begin with Foundations. If its checkpoint is already easy without notes, use the readiness assessment to locate the first missing boundary.

Open Foundations →Check my starting point
Other resources, when I need them
Beginner study methodEvidence-first debuggingComplete course catalog