---
# System prepended metadata

title: Angular Folder Structure

---


# Highly Scalable Folder Structure for Angular Project

A well-structured Angular project is crucial for scalability, maintainability, and ease of development as your application grows. Here's a guide to defining a highly scalable folder structure for an Angular project:

### 1. **Top-Level Structure**

At the top level, your project should have a clear separation between core configurations, shared resources, and feature-specific modules. Here's a suggested structure:


```
/src
  /app
    /core
    /shared
    /features
      /feature-module-1
      /feature-module-2
      ...
    /layout
    /assets
    /environments
  /styles
  /assets
  /environments
``` 

### 2. **Core Module**

The `core` module contains singleton services, configurations, and other app-wide features. Typically, it is only imported once, in the root module (`AppModule`).

**Example Structure:**

bash

Copy code

`/app
  /core
    /services
    /interceptors
    /guards
    /models
    /http
    /state
    core.module.ts` 

-   **services:** Singleton services used across the app (e.g., `AuthService`, `ApiService`).
-   **interceptors:** HTTP interceptors for handling requests and responses globally.
-   **guards:** Route guards to manage access to specific routes.
-   **models:** Shared data models used throughout the app.
-   **http:** Custom HTTP clients, error handlers, etc.
-   **state:** Global state management, using NgRx or similar.

### 3. **Shared Module**

The `shared` module contains components, pipes, and directives that are used across multiple feature modules. This module should not depend on other modules.

**Example Structure:**

```
/app
  /shared
    /components
    /directives
    /pipes
    /models
    /utils
    shared.module.ts
``` 

-   **components:** Reusable UI components (e.g., buttons, form controls).
-   **directives:** Reusable directives (e.g., `HighlightDirective`).
-   **pipes:** Reusable pipes (e.g., `DatePipe`, `CurrencyPipe`).
-   **models:** Shared models specific to shared components, directives, or pipes.
-   **utils:** Utility functions or classes that are shared across the app.

### 4. **Feature Modules**

Each feature of your application should have its own module. Feature modules encapsulate related components, services, and routing.

**Example Structure:**

```
/app
  /features
    /feature-module-1
      /components
      /services
      /models
      /pages
      /state
      feature-module-1-routing.module.ts
      feature-module-1.module.ts
``` 

-   **components:** Components specific to this feature.
-   **services:** Services that are specific to this feature.
-   **models:** Data models specific to this feature.
-   **pages:** Smart components representing full pages/views (e.g., `FeaturePageComponent`).
-   **state:** State management for this feature, if using NgRx or similar.

### 5. **Layout Module**

The `layout` module is responsible for the application’s layout, including headers, footers, sidebars, and any other layout components.

**Example Structure:**
```
/app
  /layout
    /header
    /footer
    /sidebar
    layout.module.ts
    layout-routing.module.ts
``` 

-   **header:** Components related to the application header (e.g., `NavbarComponent`).
-   **footer:** Components related to the application footer.
-   **sidebar:** Components related to the sidebar or navigation menu.

### 6. **Assets Folder**

The `assets` folder contains static assets like images, fonts, and other media.

**Example Structure:**
```
/src
  /assets
    /images
    /fonts
    /icons
    /json
``` 

-   **images:** Store application-wide images.
-   **fonts:** Custom fonts.
-   **icons:** SVGs or icon fonts.
-   **json:** Static JSON files that might be used as mock data or configuration.

### 7. **Environments Folder**

The `environments` folder contains configuration files for different environments (e.g., development, production).

**Example Structure:**
```
/src
  /environments
    environment.ts
    environment.prod.ts
    environment.staging.ts
``` 

### 8. **Global Styles and Themes**

If your application uses global styles or themes, maintain them in a dedicated folder.

**Example Structure:**

```
/src
  /styles
    /themes
    /mixins
    /variables
    styles.scss
``` 

-   **themes:** Different theme styles (light, dark, etc.).
-   **mixins:** Reusable SASS mixins.
-   **variables:** SASS variables for colors, fonts, spacing, etc.

### 9. **Routing Structure**

Each feature module should have its own routing module. The main routing module (`AppRoutingModule`) should load feature modules lazily.

**Example Structure:**

```ts
// app-routing.module.ts
const routes: Routes = [
  { path: '', redirectTo: '/home', pathMatch: 'full' },
  { path: 'feature1', loadChildren: () => import('./features/feature-module-1/feature-module-1.module').then(m => m.FeatureModule1) },
  { path: 'feature2', loadChildren: () => import('./features/feature-module-2/feature-module-2.module').then(m => m.FeatureModule2) },
  { path: '**', redirectTo: '/home' }
];
``` 

### 10. **App Module**

The `AppModule` ties everything together. It imports `CoreModule`, `SharedModule`, `LayoutModule`, and any root-level modules.

**Example Structure:**

```ts
@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    CoreModule,
    SharedModule,
    LayoutModule,
    AppRoutingModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }
``` 

### 11. **Testing Structure**

Maintain a structure for testing that mirrors your app structure, placing unit tests (`.spec.ts`) next to the files they test:

```
/app
  /core
    /services
      auth.service.spec.ts
  /shared
    /components
      button.component.spec.ts
  /features
    /feature-module-1
      /components
        feature-component.spec.ts
      /services
        feature-service.spec.ts
``` 

### 12. **Lazy Loading Modules**

Lazy load feature modules to optimize performance, especially for large applications:

```
const routes: Routes = [
  {
    path: 'dashboard',
    loadChildren: () => import('./features/dashboard/dashboard.module').then(m => m.DashboardModule)
  }
];
``` 

### 13. **Configuration Management**

If you have multiple configuration files or environment-specific settings, manage them in a dedicated configuration module or service.

**Example Structure:**

```
/app
  /config
    app-config.service.ts
    app-config.model.ts
``` 
### Full Structure
```
src/
  app/
    core/
      interceptors/
        auth.interceptor.ts
      guards/
        auth.guard.ts
      services/
        auth.service.ts
        api.service.ts
      models/
        user.model.ts
        token-response.model.ts
      utilities/
        jwt-helper.ts
      core.module.ts

    shared/
      components/
        loading-spinner/
          loading-spinner.component.ts
        card/
          card.component.ts
      directives/
        tooltip.directive.ts
      pipes/
        date-format.pipe.ts
      services/
        notification.service.ts
      shared.module.ts

    features/
      user/
        components/
          user-profile/
            user-profile.component.ts
        pages/
          user-list/
            user-list.page.ts
        services/
          user.service.ts
        models/
          user.model.ts
        user-routing.module.ts
        user.module.ts

      admin/
        components/
          admin-dashboard/
            admin-dashboard.component.ts
        pages/
          admin-overview/
            admin-overview.page.ts
        services/
          admin.service.ts
        models/
          admin.model.ts
        admin-routing.module.ts
        admin.module.ts

    assets/
      images/
      fonts/
      icons/

    environments/
      environment.ts
      environment.prod.ts

    styles/
      themes/
      mixins/
      variables/
      global.scss

    app-routing.module.ts
    app.component.ts
    app.module.ts
```
This structure allows you to maintain a highly scalable, organized, and maintainable Angular project. It separates concerns, encourages the use of Angular modules to encapsulate related functionality, and facilitates easy scaling as the project grows.