Programming Learning Paths — From Beginner to Builder

HOW PATHS WORK

A path is a dependency map, not a race.

Complete one chapter loop at a time: preview, predict, run, change, explain, practice, and retrieve. Advance when you can produce the checkpoint evidence without copying the lesson.

01Start at your real boundary.
If the first checkpoint is already easy, move forward. If its vocabulary is unclear, take the linked prerequisite.
02Choose one primary language.
Backend and systems paths offer language branches. Pick one; do not study four equivalent languages in parallel.
03Build before adding another course.
Use the stage project to expose gaps. Return to a chapter because evidence failed, not because progress feels imperfect.
04Finish with independent handoff.
Your capstone is complete when another learner can run, test, diagnose, and recover it from your documentation.

QUICK CHOICE

What do you want to build?

I have never programmedStart from files, terminals, programs, and debugging. Web interfacesBuild accessible, secure, production frontend applications. APIs and servicesOwn domain rules, databases, distributed work, and operations. Data platformsBuild replayable pipelines, analytical tables, and governed metrics. AI and RAG productsConnect math, data, models, evidence, evaluation, and safety. Systems and infrastructureTrace programs through memory, Linux, networks, cloud, and recovery. Secure softwareThreat-model and defend applications, identities, data, and operations. Mobile or desktop appsBuild lifecycle-safe products with storage, synchronization, and release.

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
Build the computer modelComputing & Programming Foundations
Files, terminals, processes, networks, program structure, testing, Git, and a complete project.
2
Learn one readable languagePython
Values, decisions, functions, collections, files, objects, errors, tests, typing, and maintainable packages.
3
Store and query factsSQL Fundamentals
Filtering, joins, aggregation, constraints, transactions, and query plans.
4
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 · WEB

Frontend Web engineering

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
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
Program the platformJavaScript
Language behavior, DOM, events, asynchronous work, modules, tests, security, and performance.
3
Model application statesTypeScript
Types, narrowing, runtime validation, generics, modules, tooling, testing, and architecture.
4
Build with a production frameworkReact & Next.js
Rendering, state, server boundaries, caching, mutations, accessibility, security, and recovery.
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 · SERVICES

Backend and API engineering

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
Choose one service language
Python, Go, Java, or C# & .NET
Finish one language course deeply. Add another only for a real platform requirement.
2
Own durable state
SQL Fundamentals → Database Engineering
Model invariants, joins, indexes, concurrency, migration, least privilege, backup, and restore.
3
Engineer the application boundaryBackend & API Engineering
Domain design, HTTP contracts, authorization, transactions, queues, workflows, observability, and overload.
4
Operate the process and request pathLinux, Networking & SRE
Processes, files, DNS, routing, sockets, TLS, proxies, limits, SLOs, incidents, and recovery.
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 SYSTEMS

Data engineering

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
Prepare language and query fluency
Python → SQL Fundamentals
Build deterministic transformations and reason about row grain before adding infrastructure.
2
Understand storage authorityDatabase Engineering
Constraints, transactions, indexes, replication, partitioning, migration, access, backup, and restore.
3
Build the complete data pathData Engineering
Contracts, replay, analytical models, columnar layout, orchestration, quality, CDC, streaming, lakehouse tables, lineage, and incidents.
4
Operate under real resourcesLinux, Networking & SRE
Learn the process, network, capacity, service-objective, and recovery evidence beneath pipeline tools.
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 AI

AI, LLM, and RAG systems

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
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
Implement trustworthy model pipelinesPython for AI & Machine Learning
Numerical work, leakage-safe splits, baselines, evaluation, RAG foundations, deployment, and monitoring.
3
Own the evidence substrateData Engineering
Version data contracts, pipelines, quality, history, lineage, access, cost, and recovery.
4
Engineer grounded language systemsLLM & RAG Systems
Tokens, embeddings, corpus lifecycle, retrieval evaluation, reranking, citations, abstention, security, cost, and rollback.
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 · INFRASTRUCTURE

Systems, Linux, and cloud reliability

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

Entry checkpoint

You can compile or run a program, navigate a shell, use Git, and explain basic memory, files, HTTP, and testing. Begin with Foundations otherwise.

1
Learn machine-near programmingC Language
Compilation, values, arrays, pointers, memory, files, concurrency, portability, and secure native programs.
2
Connect runtime to operating systemSystems Engineering
Compilation, virtual memory, processes, I/O, networking, atomics, security boundaries, profiling, and fuzzing.
3
Operate the complete request pathLinux, Networking & SRE
Linux lifecycle, descriptors, shell safety, DNS, routing, sockets, HTTP/TLS, capacity, SLOs, and incidents.
4
Automate reproducible operationsDevOps Engineering
Artifacts, configuration, infrastructure code, containers, delivery, security, observability, and recovery.
5
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 · DEFENSE

Cybersecurity and application security

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
Understand application boundaries
Web Application Engineering → Backend & API Engineering
Learn browsers, sessions, inputs, outputs, domain rules, transactions, queues, and distributed failure.
2
Understand host and network authorityLinux, Networking & SRE
Processes, files, permissions, names, packet paths, TLS, proxies, evidence, and operational recovery.
3
Build the security programCybersecurity & Application Security
Threat modeling, identity, authorization, injection, cryptography, dependencies, cloud controls, detection, and incident response.
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 APPLICATIONS

Mobile and desktop product engineering

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
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
Engineer mobile lifecycle when applicableMobile Engineering
Lifecycle-safe state, declarative UI, offline synchronization, permissions, accessibility, migrations, deep links, observability, and stores.
3
Engineer desktop lifecycle when applicableDesktop Application Engineering
Responsive state, undo, persistence, synchronization, plugins, diagnostics, accessibility, packaging, and secure updates.
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

Choose the first missing boundary, not the longest path.

If you are unsure, begin with Foundations. If you can explain and demonstrate its chapter checkpoints already, jump to the path stage where the vocabulary becomes uncertain.

Open Foundations →Prove your starting point Read the beginner study method Learn evidence-first debugging Browse all 41 courses