Skip to content

Course guide

Audience

This course is for experienced frontend engineers building modern Angular fluency. It assumes professional TypeScript, component UI, HTTP, testing, and browser experience; it does not assume equal strength in every Angular subskill.

Core loop

Run this loop per concept rather than reading the site linearly:

Assess → Map → Learn → Practice → Challenge → Review → Advance

  1. Use one question from the adaptive diagnostic.
  2. Record Dreyfus level, confidence, mastery, and evidence in the learning map.
  3. Solid: take the verification/Bloom challenge and skip if it holds. Fragile: read the missing model and practice. Gap: complete the full lesson. Unmapped: diagnose first.
  4. Attempt the mini lab before opening a hint. Use small hint → retry → stronger hint → retry → solution direction only as a last resort.
  5. Schedule retrieval at roughly +1 day, +7 days, and +21 days.

Lesson rhythm

Each lesson focuses on one engineering capability:

  • objective and prerequisites;
  • mental model, why it exists, and where the working model differs from runtime reality;
  • minimal example and production use;
  • experienced-engineer mistakes;
  • deliberate-practice mini lab with staged hints;
  • observable verification and Bloom challenge;
  • spaced retrieval and the next dependency.

The repository contains the completed reference application. Work in a separate branch or recreate the named feature before comparing with source.

Mastery threshold

Exposure is not mastery. Advance a concept through Unknown → Exposed → Understood → Practiced → Applied → Mastered.

Mark Mastered only when you have:

  • explained the mechanism in your own words;
  • applied it without a recipe;
  • diagnosed or adapted it under a changed constraint;
  • passed a later retrieval check.

On a mistake, first write what you believed, why it seemed reasonable, where it diverged from evidence, and the corrected model. Then retry a modified problem.

Production definition of done

A lab is applied—not merely read—when:

  • behavior works with keyboard and pointer input;
  • strict template compilation and relevant tests pass;
  • loading, empty, error, invalid, and teardown states are addressed where relevant;
  • state ownership and provider lifetime are explicit;
  • performance and security claims use evidence rather than assumption;
  • you can explain the mechanism, tradeoff, and operational failure mode;
  • you can name evidence that would change your design.

Stable and experimental APIs

Core lessons use stable Angular 21 APIs. Signal Forms and Angular Aria were experimental or developer-preview in Angular 21, so they remain optional evaluations. Strictly typed reactive forms and established accessibility patterns are the production baseline.

Suggested routes

  • Calibration: Lessons 1–3, verified quickly when fundamentals are solid.
  • Core fluency: Lessons 4–10 for state, DI, routing, forms, HTTP, RxJS, and tests.
  • Production engineering: Lessons 11–12 plus debugging and system-design challenges.
  • Independent synthesis: Capstone, final mastery assessment, then optional interview rehearsal.

Do not skip calibration because syntax looks familiar; skip it only after a prediction/application check confirms the runtime model.