Home / Angular / Standalone Components Angular 17

Standalone Components Angular 17

Learn how to use Standalone Components in Angular 17 for building cleaner and more modular applications. Step-by-step guide to create, integrate, and manage Standalone Components in Angular, from setting up simple standalone entities to integrating them within traditional modules and other standalone components.

Create New Standalone Component Angular

Angular introduced standalone components in Angular 14 as a way to simplify application architectures by removing the necessity for NgModules. This approach aimed to streamline the development process and reduce boilerplate. However, with the release of Angular 17, there have been enhancements and more widespread adoption of standalone features.

Setup Your Angular Project: Make sure you have an Angular project set up. If you don’t have one, you can create a new project using Angular CLI.

If you are new to angular development refer article below to set up angular environment and getting started.

Angular project Setup Step by Step Practical Tutorial – Full Stack Tutorials Hub

How an Angular App gets Loaded and Started – Full Stack Tutorials Hub

Angular Project Structure

Navigate to your Angular project directory

Use the Angular CLI to generate a standalone component. The --standalone flag is used to specify that the component does not require an NgModule.

ng generate component MyStandalone --standalone

MyStandalone is name of your Component

We will create Employee Component.

ng generate component Employee --standalone

employee component is created in employee folder.

Standalone Components Angular

Implement the Component: Edit the generated component files to implement your component’s logic and template.


import { Component } from '@angular/core';

  selector: 'app-employee',
  standalone: true,
  imports: [],
  templateUrl: './employee.component.html',
  styleUrl: './employee.component.css'
export class EmployeeComponent {



<p>employee standalone component works!</p>

project details

How to use standalone component in angular

If you want to use this standalone component inside a traditional component that is part of an NgModule, you need to ensure the NgModule knows about this standalone component.

Although standalone components don’t require being declared in modules, they do need to be imported if they are to be used within the templates of components that are declared in NgModules.

You import a standalone component into an NgModule using the imports array of the NgModule decorator, similar to how you would import another module.

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';
import {EmployeeComponent} from './employee/employee.component'

  declarations: [
  imports: [

  providers: [],
  bootstrap: [AppComponent]
export class AppModule { }

How to use standalone component in another component

Now that you’ve imported the standalone component into the NgModule, you can use it within any component’s template that is part of this module.

This setup allows you to integrate standalone components within traditional Angular modules seamlessly. The standalone component takes care of its dependencies via its imports array, which is a distinct advantage as it encapsulates its functionality completely.

We will load employee component inside app component.

<main class="main">
  <div class="content">

Rebuilt application and visit http://localhost:4200/.

App component is loaded by default which would internally calls Employee component.

How to use standalone components inside another standalone components

Using standalone components within other standalone components in Angular is straightforward thanks to their self-contained nature. This is one of the key benefits of standalone components: they can import other standalone entities directly, which simplifies the modular structure of your Angular application. Here’s how you can do this.

First, you’ll need at least two standalone components. Let’s create a simple example with one standalone component using another.

Child Standalone Component:

// file: child-standalone.component.ts
import { Component, NgModule } from '@angular/core';

  selector: 'app-child-standalone',
  template: `<p>This is the child standalone component.</p>`,
  standalone: true
export class ChildStandaloneComponent {}

Create Parent Standalone Component and Import the Child

In the parent standalone component, you import the child standalone component directly in the imports array of the Component decorator. This is akin to how you would import modules, but now applied to components.

Parent Standalone Component:

// file: parent-standalone.component.ts
import { Component } from '@angular/core';
import { ChildStandaloneComponent } from './child-standalone.component';

  selector: 'app-parent-standalone',
  template: `
      <h1>Parent Standalone Component</h1>
      <app-child-standalone></app-child-standalone> <!-- Using the child standalone component -->
  standalone: true,
  imports: [ChildStandaloneComponent] // Import the child standalone component here
export class ParentStandaloneComponent {}

Use the Parent Standalone Component

// file: app.component.ts
import { Component } from '@angular/core';
import { ParentStandaloneComponent } from './parent-standalone.component';

  selector: 'app-root',
  template: `
    <app-parent-standalone></app-parent-standalone> <!-- Using the parent standalone component -->
  standalone: true,
  imports: [ParentStandaloneComponent] // Import the parent standalone component
export class AppComponent {}

How to migrate an Angular application to standalone components?

  • Identify the Component:Determine which component you want to convert to a standalone component.
  • Remove NgModule Association : Remove the component from any NgModule declarations it’s currently part of. This includes removing it from declarations, imports, and exports arrays in the NgModule.
  • Add Standalone Flag : Modify the component decorator to include the standalone flag. You might also need to ensure that any dependencies (like other components, directives, or pipes used by this component) are also migrated to standalone or imported directly using the imports property in the component decorator.

Before Migration:

// In some-module.module.ts
  declarations: [SomeComponent],
  imports: [CommonModule],
  exports: [SomeComponent]
export class SomeModule {}

After Migration:

// some.component.ts
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';

  selector: 'app-some',
  standalone: true,
  imports: [CommonModule],
  template: `<p>Standalone component works!</p>`,
export class SomeComponent {}

Update Usage in Application : Since the component is now standalone, you can directly use it in any template without needing to import the host module. Ensure all places using this component are updated if the component’s selector or API has changed.

By migrating to standalone components, Angular applications can potentially reduce their complexity and increase the reusability of components across different parts of the application.

Enhancements and Changes Standalone Components Angular 17

With Angular 17, the standalone API was further enhanced and promoted as the primary way to develop Angular components, directives, and pipes. The changes and enhancements include.

  • Improved Tooling Support:Angular CLI and developer tools have improved support for creating and managing standalone components, making it easier for developers to adopt this pattern.
  • Lazy Loading:tandalone components support improved lazy loading, making it easier to dynamically load parts of the application without complex NgModule configurations.
  • Scoped Styles:There’s improved support for scoped styles with standalone components, allowing styles to be better encapsulated and managed.
  • More Comprehensive Documentation and Examples : As standalone components became a recommended practice, Angular documentation and community examples have expanded, providing better guidance and best practices.
  • Community Adoption and Feedback:With more developers using standalone components, feedback from the community has helped shape bug fixes, performance improvements, and feature enhancements.
  • Route Integration:Angular 17 made it simpler to define routes using standalone components. You can directly reference standalone components in routing configurations without wrapping them in an NgModule.
Can standalone components import other components?

Yes, standalone components can import other standalone components or directives directly in their imports array in the component decorator. This allows them to be highly modular and self-contained.

How do standalone components differ from regular components?

Standalone components differ from regular components in that they do not require an NgModule for declaration. They manage their own imports and can be used independently, which reduces the complexity of using NgModules for component management.

Can standalone components be lazy-loaded?

es, standalone components can be lazy-loaded, enhancing application performance. They can be configured in Angular routes with lazy loading patterns similar to regular components but without needing a separate NgModule.

Are standalone components compatible with all Angular versions?

tandalone components were introduced in Angular 14. They are not backward compatible with earlier versions of Angular. However, from Angular 14 onwards, you can use standalone components alongside traditional NgModules.

Scroll to Top