About Angular
Angular is a TypeScript-based framework for building large, maintainable web
applications. It ships with routing, forms, an HTTP client, and dependency injection
built in, which is why it's a common choice for enterprise front ends. This course
walks through it the way most developers actually learn it. It starts with
Introduction to Angular (what it is, how it's structured, and how it
compares to other frameworks) and Installation & Angular CLI
(Node, the CLI, project structure, and running your first app).
Next comes Components & Templates: standalone components, data
binding, inputs and outputs, and the modern control flow syntax. That leads into
Directives & Pipes for changing how the DOM behaves and how data
is displayed, and Services & Dependency Injection for sharing
logic and state cleanly across your application.
Routing & Navigation covers multi-page apps, route parameters,
guards, and lazy loading. Forms & Validation covers both
template-driven and reactive forms, and HTTP, Observables & RxJS
covers talking to APIs and handling asynchronous data streams with HttpClient,
interceptors, and operators.
Finally, Signals & State Management covers Angular's modern
reactivity model and patterns for managing application state, and
Testing, Build & Deployment covers unit and end-to-end testing,
production builds, performance, and shipping your app: the natural last step once
building features feels routine.
Content
10 modules
01
Introduction to Angular
What Angular is, how its architecture fits together, and how it compares to other front-end frameworks you might know.
ArchitectureTypeScriptAngular vs React & Vue
02
Installation & Angular CLI
Setting up Node.js and the Angular CLI, generating a project, and understanding the folder structure and config files.
Node.jsng newProject Structure
03
Components & Templates
Building the UI from standalone components, binding data to templates, and passing data between parent and child.
Standalone ComponentsData Binding@Input & @Output
04
Directives & Pipes
Controlling templates with built-in control flow and directives, and formatting data with pipes, including your own custom ones.
@if / @forAttribute DirectivesCustom Pipes
05
Services & Dependency Injection
Sharing logic and data across components with services, and how Angular's injector provides them where they're needed.
Injectableinject()Providers
06
Routing & Navigation
Turning a single page into a multi-view app with routes, parameters, guards, and lazy-loaded features.
RouterRoute GuardsLazy Loading
07
Forms & Validation
Collecting and validating user input with template-driven and reactive forms, including custom validators.
Template-DrivenReactive FormsValidators
08
HTTP, Observables & RxJS
Fetching and sending data to APIs with HttpClient, and handling asynchronous streams with observables and operators.
HttpClientObservablesInterceptors
09
Signals & State Management
Angular's signal-based reactivity, derived state, and patterns for managing shared application state as apps grow.
Signalscomputed & effectNgRx
10
Testing, Build & Deployment
Testing components and services, optimizing production builds, and deploying your app to the web.
Unit TestingE2E TestingProduction Build
What You Can Do After This Course
By the end of the curriculum you'll have worked through 5 hands-on projects and
covered the core of what a front-end role expects from someone who "knows Angular."
Concretely, you'll be able to:
Scaffold and run Angular apps — use the CLI confidently and understand how a project is organized.
Build UIs from components — bind data, handle events, and pass data between components cleanly.
Share logic with services — use dependency injection to keep components small and code reusable.
Create multi-page applications — configure routing, protect routes with guards, and lazy-load features.
Handle user input — build and validate forms using both template-driven and reactive approaches.
Work with APIs and async data — fetch data with HttpClient and manage streams with RxJS.
Manage state and ship with confidence — use signals for reactivity, write tests, and deploy optimized production builds.