Angular engineering learning map¶

This course measures what you can build, explain, debug, and defend, not how much documentation you have read. Start with the adaptive diagnostic, record evidence below, and choose the next lesson from the adaptive roadmap.

Learning destination¶

By the end of the course you can:

Build: a production-shaped Angular 21 application with standalone components, signals, routes, typed forms, HTTP boundaries, RxJS pipelines, and focused tests.
Explain: rendering, view identity, state ownership, injector scope, routing, validation, cancellation, and test boundaries without relying on memorized slogans.
Decide: where state and providers live; when signals, RxJS, guards, resolvers, lazy loading, or indirection are justified; and what evidence could reverse the choice.
Diagnose: stale UI, duplicate providers or requests, invalid form payloads, stream termination, rendering cost, SSR failures, and inaccessible state changes.
Operate: reason about security, accessibility, observability, performance budgets, deployment, rollback, and backward compatibility.

The capstone is an independent production-like feature change with implementation, failure handling, tests, operational evidence, and a design defense.

Prerequisites¶

Professional TypeScript and browser experience is assumed. You should be comfortable with component-based UIs, HTTP, tests, promises, and basic observable vocabulary. Use the TypeScript diagnostic and refresher only for demonstrated gaps.

Placement by subskill¶

Rate evidence separately; there is no single global Angular level.

Level	Observable behavior
Novice	Follows rules or examples but cannot predict consequences when context changes.
Advanced beginner	Completes familiar tasks and recognizes vocabulary, but misses ownership and failure boundaries.
Competent	Plans and implements a feature, debugs common failures, and explains routine tradeoffs.
Proficient	Sees system interactions, adapts patterns to constraints, and uses evidence to choose among alternatives.
Expert	Forms and tests new models, handles ambiguous production constraints, and teaches the reasoning precisely.

Track these areas independently: fundamentals, runtime/internals, architecture, debugging, performance, security, and production operations.

Confidence and mastery¶

Confidence selects the route:

Solid: perform one verification challenge; skip the lesson if the evidence holds.
Fragile: read only the missing mental model, then complete the mini lab and analysis challenge.
Gap: work through the full lesson with staged hints.
Unmapped: diagnose before choosing.

Mastery records progress: Unknown → Exposed → Understood → Practiced → Applied → Mastered.

A concept becomes Mastered only after you explain it in your own words, apply it successfully, and pass a later spaced-retrieval check. One correct definition or completed walkthrough is not mastery.

Evidence record¶

Copy one row per concept into your notes. Use dates rather than checkmarks so retrieval can be scheduled.

Concept	Dreyfus level	Confidence	Mastery	Evidence	Misconception found	Next action	Review dates
Example: list identity	Competent	Fragile	Applied	Fixed reorder bug and explained DOM identity	Thought text equality preserved child state	Re-test in Lab 11	+1d, +7d, +21d

Advancement rules¶

Predict before running code.
Attempt before opening a hint.
Use the smallest hint, then retry.
Record the mental model behind a mistake before correcting it.
Advance after observable evidence, not “I understand.”
Revisit concepts after roughly one day, one week, and three weeks; increase the interval after successful retrieval.

Error-driven correction¶

When an answer or implementation is wrong, record:

What did I believe?
Why did it seem reasonable?
Where does it diverge from Angular/browser/runtime behavior?
What evidence demonstrates the divergence?
What corrected model predicts both the original and changed scenario?

Then retry a modified problem. Fixing only the original answer does not demonstrate a repaired model.