diff --git a/docs/cli/generate.md b/docs/cli/generate.md
index 0f1e8f5b..b48cb6a9 100644
--- a/docs/cli/generate.md
+++ b/docs/cli/generate.md
@@ -45,38 +45,25 @@ We provide two different structures to scaffold the resources:
 
 Current available resources:
 
-| Long form  | short |
-| ---------- | ----- |
-| usecase    | u     |
-| controller | c     |
-| dto        | d     |
-| provider   | p     |
-| service    | s     |
-| entity     | e     |
-| middleware | m     |
-
-## Usage Example
-
-| Command                    | Expected result                                                                          |
-| -------------------------- | ---------------------------------------------------------------------------------------- |
-| expressots g u user/find   | Use case to be created in the folder `useCases` with this folder structure: user/find    |
-| expressots g c user/find   | Controller to be created in the folder `useCases` inside of user/find                    |
-| expressots g d user/find   | DTO to be created in the folder `useCases` inside of user/find                           |
-| expressots g p email/email | Provider to be created in the folder `providers` inside of user/find                     |
-| expressots g s user/find   | Service creates usecase, controller and DTO and add them in the desired folder user/find |
-| expressots g e user        | Entity to be created in the folder `entities` with this folder structure: user           |
-| expressots g m auth        | Middleware to be created in the folder `middlewares` with this folder structure: auth    |
+| Long form  | short | Command                    | Expected result                                                                          |
+| ---------- | ----- | -------------------------- | ---------------------------------------------------------------------------------------- |
+| usecase    | u     | expressots g u user/find   | Use case to be created in the folder `useCases` with this folder structure: user/find    |
+| controller | c     | expressots g c user/find   | Controller to be created in the folder `useCases` inside of user/find                    |
+| dto        | d     | expressots g d user/find   | DTO to be created in the folder `useCases` inside of user/find                           |
+| provider   | p     | expressots g p email/email | Provider to be created in the folder `providers` inside of user/find                     |
+| service    | s     | expressots g s user/find   | Service creates usecase, controller and DTO and add them in the desired folder user/find |
+| entity     | e     | expressots g e user        | Entity to be created in the folder `entities` with this folder structure: user           |
+| middleware | mi    | expressots g mi auth       | Middleware to be created in the folder `middlewares` with this folder structure: auth    |
+| module     | mo    | expressots g mo user       | Module to be created in the folder where `controllers` and `usecases` are located        |
 
 All resources can be created using the structure `folder/subfolder/resource`.
 
-For services, you can take advantage of creating the use case, controller and DTO at once using the structure `entity_action` or `entity-action`. Example: `expressots g s user-create`.
+## Scaffolding using hyphenated names
 
-:::caution
-The `expressots.config.ts` configuration file, located in the project root folder, determines where all resources will be created.
-:::
+For services, you can take advantage of creating the use case, controller and DTO at once using the structure `entity_action` or `entity-action`. Example: `expressots g s user-create`.
 
 :::info
-All usecases, controllers and DTOs are being inside of the `useCases` folder. However, this may change in the future.
+The `expressots.config.ts` configuration file, located in the project root folder, determines where all resources will be created.
 :::
 
 ## ExpressoTS Config File
@@ -91,7 +78,16 @@ import { ExpressoConfig, Pattern } from "@expressots/core";
 const config: ExpressoConfig = {
     sourceRoot: "src",
     scaffoldPattern: Pattern.KEBAB_CASE,
-    opinionated: false,
+    opinionated: true,
+    scaffoldSchematics: {
+        entity: "entity",
+        provider: "provider",
+        module: "module",
+        controller: "controller",
+        dto: "dto",
+        middleware: "middleware",
+        usecase: "useCases",
+    },
 };
 
 export default config;
@@ -100,6 +96,7 @@ export default config;
 -   **sourceRoot**: the root folder that will be used by the CLI to create the resources. Default: `src`
 -   **scaffoldPattern**: the pattern that will be used to create the resources. Default: `Pattern.KEBAB_CASE`. Example: `user-create`
 -   **opinionated**: if true, the CLI will create the resources using the opinionated folder structure
+-   **scaffoldSchematics**: the folder convention names for each resource. Default: `useCases`, `entities`, `providers`, `middlewares`, `controllers`, `dtos`
 
 ## Recommendations
 
diff --git a/docs/cli/overview.md b/docs/cli/overview.md
index 9c9023ff..7b79ad55 100644
--- a/docs/cli/overview.md
+++ b/docs/cli/overview.md
@@ -18,7 +18,7 @@ First install the CLI globally using the command below:
 npm install -g @expressots/cli
 ```
 
-## Basic Usage
+## Basic usage
 
 ```bash
 expressots <command> [options]
@@ -37,9 +37,19 @@ expressots --help
 Providers information about your Operational System, Project and CLI version:
 
 ```bash
-expressots info
+expressots info or i
 ```
 
+### Resources list
+
+List all available resources to scaffold:
+
+```bash
+expressots resources or r
+```
+
+![Resources](../overview/img/scaffold-resources.png)
+
 ## Create a Project
 
 There are two options to create a new project, interactively or silently (passing the options as arguments).
@@ -61,9 +71,9 @@ expressots new <project-name>
 expressots new <project-name> -p <package-manager> -t <template> -d <directory>
 ```
 
-- **package-manager**: `npm`, `yarn` or `pnpm`
-- **template**: `opinionated` or `non-opinionated`
-- **directory**: `./my-project`
+-   **package-manager**: `npm`, `yarn` or `pnpm`
+-   **template**: `opinionated` or `non-opinionated`
+-   **directory**: `./my-project`
 
 The flag `-d` is optional and is used to specify the directory where the project will be created. If not specified, the project will be created in the current directory.
 
@@ -73,9 +83,9 @@ The flag `-d` is optional and is used to specify the directory where the project
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/codebyexample/app-container.md b/docs/codebyexample/app-container.md
index 019c9f5f..81512f2a 100644
--- a/docs/codebyexample/app-container.md
+++ b/docs/codebyexample/app-container.md
@@ -10,8 +10,8 @@ The application container is a dependency injection container. See [Application
 const appContainer = new AppContainer();
 
 export const container: Container = appContainer.create([
-  // Add your modules here
-  AppModule,
+    // Add your modules here
+    AppModule,
 ]);
 ```
 
@@ -19,8 +19,9 @@ export const container: Container = appContainer.create([
 
 The `AppContainer` class takes one optional parameter:
 
-- `defaultScope` is the default binding scope. Use `BindingScopeEnum` to set the default scope (Request, Singleton, Transient).
-- `skipBaseClassChecks` is a boolean value that indicates if the container should skip the base class checks. This is useful when you are using abstract classes as binding identifiers or you are extending classes from third-party libraries. Set this value to `true` to skip the base class checks.
+-   `defaultScope` is the default binding scope. Use `BindingScopeEnum` to set the default scope (Request, Singleton, Transient).
+-   `skipBaseClassChecks` is a boolean value that indicates if the container should skip the base class checks. This is useful when you are using abstract classes as binding identifiers or you are extending classes from third-party libraries. Set this value to `true` to skip the base class checks.
+-   `autoBindInjectable` is a boolean value that indicates if the container should automatically bind injectable classes. Set this value to `true` to automatically bind injectable classes.
 
 :::info
 The default scope is `BindingScopeEnum.Request` and `skipBaseClassChecks` is `false`.
@@ -28,17 +29,18 @@ The default scope is `BindingScopeEnum.Request` and `skipBaseClassChecks` is `fa
 
 ```typescript
 const appContainer = new AppContainer({
-  defaultScope: BindingScopeEnum.Request,
-  skipBaseClassChecks: true,
+    defaultScope: BindingScopeEnum.Request,
+    skipBaseClassChecks: true,
+    autoBindInjectable: false,
 });
 ```
 
 The `AppContainer` instance returns an instance of `AppContainer` that gives you access to the following methods:
 
-- `create()` creates the application container.
-- `Container` is the dependency injection container instance.
-- `getBindingDictionary()` returns the binding dictionary map of classes injected in the dependency injection system.
-- `getContainerOptions()` returns the container options.
+-   `create()` creates the application container.
+-   `Container` is the dependency injection container instance.
+-   `getBindingDictionary()` returns the binding dictionary map of classes injected in the dependency injection system.
+-   `getContainerOptions()` returns the container options.
 
 ### Method Create
 
@@ -46,10 +48,10 @@ The `create` method takes one mandatory parameter (array of modules);
 
 ```typescript
 export const container: Container = appContainer.create([
-  // Add your modules here
-  AppModule,
-  UserModule,
-  ProductModule,
+    // Add your modules here
+    AppModule,
+    UserModule,
+    ProductModule,
 ]);
 ```
 
@@ -59,9 +61,9 @@ export const container: Container = appContainer.create([
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/hello.md b/docs/hello.md
index 51697b60..ebeb7b39 100644
--- a/docs/hello.md
+++ b/docs/hello.md
@@ -2,50 +2,44 @@
 sidebar_position: 0
 ---
 
-# Hello, Dev
+# Welcome to ExpressoTS
 
-ExpressoTS strives to abstract away the complexities of software development to make it eaiser for you to build your next project. We want to make you more productive and help you focus on what matters the most, your business logic.
+ExpressoTS is designed to simplify the software development process, enabling developers to concentrate on the core business logic by abstracting technical complexities. Our goal is to enhance your productivity through a framework that not only accelerates development but also offers comprehensive documentation and a superior developer experience, minimizing the necessity for boilerplate code.
 
-If you think about it, every programming language feature or framework is built to accelerate the development process, but most fail to deliver good documentation, good developer experience, or to reduce the amount of boilerplate code you have to write. We want to change that.
+Our commitment is twofold: to simplify your development work and to enhance your productivity. As we embark on this journey, we invite you to join our community-driven project. Your insights, feedback, and contributions are invaluable in creating an optimal developer experience for everyone.
 
-> This is our commitment: to make your life easier, and to make you more productive.
+We appreciate your support in this endeavor. Let's code efficiently together. 🐎
 
-As a community-driven project, we want you to be part of this journey with us. Your feedback, ideas, and contributions will help us build a better developer experience for everyone.
+## Navigating the Documentation
 
-Thanks for joining us in this challenge. Happy coding! 🐎
+This documentation is organized into distinct sections, each focusing on a specific aspect of ExpressoTS. Utilize the sidebar on the left to navigate through the content:
 
----
-
-## How to Read this Documentation
-
-The documentation is divided into several sections, each one covering a different topic. You can navigate through the documentation using the sidebar on the left side of the page.
+-   **Overview**: Provides general information about ExpressoTS, including project resources, concepts, objectives, and initial setup instructions.
+-   **Code By Example**: Offers practical examples to demonstrate the application of ExpressoTS resources.
+-   **CLI**: Details the command-line interface, including usage instructions.
+-   **Providers**: Describes the available providers and their utilization.
+-   **Tutorial**: A comprehensive, step-by-step guide to accomplishing specific tasks within ExpressoTS.
+-   **Roadmap**: Outlines the future direction and planned features of ExpressoTS.
+-   **Governance**: Explains the governance model of ExpressoTS and outlines how to contribute to the project.
 
-- **Overview**: General information about the project resources, concepts, its goals, and how to get started.
-- **Code By Example**: A collection of examples that demonstrate how to use the project resources in a more practical way.
-- **CLI**: Information about the command-line interface and how to use it.
-- **Providers**: Information about the providers and how to use them.
-- **Tutorial**: A step-by-step guide explaining how to perform a specific task.
-- **Roadmap**: A list of features that are planned for future releases.
-- **Governance**: Information about the project governance and how to contribute.
-
----
+## Understanding Alert Types
 
-## Alert Types
+Throughout this documentation, various formats are used to draw attention to different types of information:
 
-- **[links](./overview/intro.md)**: Bold text denotes a link to other pages of the documentation or external locations.
-- `code`: Emphasized code snippets and commands, or key technical terms.
-- Alerts: Are used to highlight important information.
+-   **Links**: Bold text indicates hyperlinks to other documentation pages or external resources.
+-   **Code**: Code snippets, commands, and key technical terms are highlighted.
+-   **Alerts**: Specific alerts are employed to emphasize crucial information, utilizing the following markers:
 
-  :::note ( note ) Used to express general information
-  :::
-  :::tip ( tip ) This is a tip
-  :::
-  :::info ( info ) Extra information that is not vital
-  :::
-  :::caution ( caution ) Used to indicate spoilers
-  :::
-  :::warning ( warning ) Used to indicate when something could go wrong
-  :::
+:::note Conveys general information or reminders.
+:::
+:::tip Provides helpful suggestions or best practices.
+:::
+:::info Offers additional, non-critical information.
+:::
+:::caution Alerts to potential spoilers or sensitive content.
+:::
+:::warning Signals potential issues or risks that could impact development.
+:::
 
 ---
 
@@ -53,9 +47,9 @@ The documentation is divided into several sections, each one covering a differen
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/overview/app-container.md b/docs/overview/app-container.md
index 7ef93ef3..b75f5f98 100644
--- a/docs/overview/app-container.md
+++ b/docs/overview/app-container.md
@@ -4,45 +4,50 @@ sidebar_position: 3
 
 # App Container
 
-The ExpressoTS uses **[InversifyJS](https://inversify.io/)** as its IoC (Inversion of Control) container. InversifyJS is a powerful tool for managing dependency injection. It is a type-aware container that can be used to manage the instantiation and resolution of objects, as well as the management of their life cycles.
+ExpressoTS leverages **[InversifyJS](https://inversify.io/)** for its Inversion of Control (IoC) container capabilities, providing a robust system for dependency injection. This type-aware container facilitates object instantiation, resolution, and life cycle management, enabling the creation of complex dependencies with minimal code.
 
-The container provides a central location for managing dependencies and creating objects that depend on other objects. When a class is registered with the container, it becomes immediately available for injection into other classes. This allows for the creation of complex object graphs with minimal boilerplate code.
+The AppContainer wrapper simplifies integration, allowing for straightforward registration of controllers, use cases, and providers within the application.
 
-Taking advantage of InversifyJS, we created a wrapper to reduce complexity on how controllers, use cases, and providers get injected within the application container. The wrapper is called `AppContainer` and it is responsible for registering all the application modules within the container.
+## Configuring the container
 
-## Creating the Container
+The application container can be customized with default scopes for dependency binding and options to skip base class checks, enhancing flexibility in dependency management.
 
-Upon creating the application container, it is possible to define the default scope of the container as well as setting the container to skip base class checks. The default scope is `RequestScope` which means that all dependencies will be created once per request. This is the common scope for most web applications used in other frameworks such as Spring Boot or .NET Core.
+-   **defaultScope**: The default scope, `RequestScope`, creates a new instance of a dependency for each request, while `SingletonScope` creates a single instance shared across all requests. The `TransientScope` creates a new instance each time the dependency is requested.
+-   **skipBaseClassChecks**: When set to `true`, the container will skip base class checks when working with derived classes.
+-   **autoBindInjectable**: When set to `true`, the container will automatically inject classes that are not explicitly bound.
 
 Here is the interface options definition:
 
 ```typescript
 interface ContainerOptions {
-  /**
-   * The default scope for bindings in the container.
-   * It can be set to Request (default), Singleton, or Transient.
-   */
-  defaultScope?: interfaces.BindingScope;
-
-  /**
-   * Allows skipping of base class checks when working with derived classes.
-   */
-  skipBaseClassChecks?: boolean;
+    /**
+     * The default scope for bindings in the container.
+     * It can be set to Request (default), Singleton, or Transient.
+     */
+    defaultScope?: interfaces.BindingScope;
+
+    /**
+     * Allows skipping of base class checks when working with derived classes.
+     */
+    skipBaseClassChecks?: boolean;
+
+    /**
+     * Allows auto-injection of classes that are not explicitly bound to the container.
+     */
+    autoBindInjectable: false;
 }
 ```
 
-Here is an example on how to create a container:
+Creating the container
 
 ```typescript
 // Adding options to the container
-const appContainer = new AppContainer({
+export const appContainer: AppContainer = new AppContainer({
     defaultScope: BindingScopeEnum.Singleton,
     skipBaseClassChecks: true,
+    autoBindInjectable: false,
 });
 
-// Creating a container without options
-const appContainer = new AppContainer();
-
 // Creating a container module manager
 const container = appContainer.create([
     // Add your modules here
@@ -52,49 +57,41 @@ const container = appContainer.create([
 export { container };
 ```
 
-## Defining the Container Scope
+## Defining the container scope
 
 As mentioned above, if the `defaultScope` option is not provided, it defaults to `RequestScope`. However, it is possible to change the default scope by passing the `defaultScope` as a an option in the container constructor. The `BindingScopeEnum` contains the following values:
 
-- `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
-- `BindingScopeEnum.Request` - The dependency will be created once per request.
-- `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
+-   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
+-   `BindingScopeEnum.Request` - The dependency will be created once per request.
+-   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
 
-```typescript
-const appContainer = new AppContainer();
+## Viewing container bindings
 
-const container = appContainer.create(
-    [
-        // Add your modules here
-    ]
-);
+The container can be used to view all the bindings that have been registered. This can be useful for debugging purposes or to understand the dependencies that have been registered.
+
+```typescript
+appContainer.viewContainerBindings();
 ```
 
-:::tip
-If you don't pass the `defaultScope` the default scope is set to `RequestScope`.
-:::
+![Container Bindings View](./img/container-bindings.png)
 
 ## Registering Modules
 
-The `AppContainer` class has a `create` method that receives an array of modules and returns the container with all the modules registered. The newly created container is the same container that is used by the `Application` class to initialize the server.
-
-Once the container is created, developers can register **[modules](./module.md)** within the container:
+The `appContainer` facilitates module registration via its `create([])` method, which accepts an array of modules. This streamlined approach reduces setup complexity and aligns with ExpressoTS's goal of simplifying application architecture:
 
 ```typescript
 // Create a new container
-const appContainer = new AppContainer();
+const appContainer: AppContainer = new AppContainer();
 
-const container = appContainer.create([
+const container: Container = appContainer.create([
     // Register all the modules
     UserModule,
     PaymentModule,
-    ProductModule
+    ProductModule,
 ]);
-
-export default container;
 ```
 
-The `AppContainer` class was created to reduce the complexity of how the container is constructed using Inversify directly. It also provides a way to register modules without too much extra configuration.
+The use of `appContainer` abstracts away the intricacies of InversifyJS direct usage, providing a straightforward path to integrating and managing modules within ExpressoTS applications.
 
 ---
 
@@ -102,9 +99,9 @@ The `AppContainer` class was created to reduce the complexity of how the contain
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
\ No newline at end of file
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/overview/application.md b/docs/overview/application.md
index 9309e035..eae7b7bd 100644
--- a/docs/overview/application.md
+++ b/docs/overview/application.md
@@ -4,201 +4,98 @@ sidebar_position: 2
 
 # Application
 
-The Application Overview provides a comprehensive demonstration of the main components of an ExpressoTS application. At the heart of an ExpressoTS application lies the Application class. It serves as the foundation for creating and configuring the server. Additionally, the Application class makes use of the application container from Inversify that loads all the modules, including their respective routes [controllers]. This ensures a streamlined and efficient process for handling incoming requests and delivering the appropriate responses.
+At the heart of an ExpressoTS application lies the `App` class. It serves as the foundation for creating and configuring the server. Additionally, the App class allows middleware and providers to be configured in the server bootstrapping process. The App class also provides lifecycle hooks that allow developers to execute code before, after, and on server shutdown. This section provides an overview of the ExpressoTS application architecture, its components, and the workflow of an ExpressoTS application.
 
 ![Application Overview](./img/app-overview.png)
 
-ExpressoTS is a web application framework that provides a wrapper around popular HTTP servers, including **[Express](https://expressjs.com)** and **[Fastify](https://www.fastify.io/)**.
-
-:::info
-Currently, only Express has been thoroughly tested by the ExpressoTS team. Fastify adapter is a work-in-progress.
-:::
+## Application architecture
 
 The architecture of an ExpressoTS application is built around the **[Inversify](https://inversify.io/)** IoC container, which is used to identify and inject dependencies into class constructors. This approach allows the IoC container to load all the necessary modules, including their respective routes (controllers). By using use-cases and providers as needed, routers can handle incoming requests.
 
-By leveraging the power of Inversify, ExpressoTS provides a custom Dependency Injection system that is scalable and modular. This creates an architecture that helps to decouple components and improve maintainability, allowing developers to focus on writing clean and maintainable code.
+## Core components and their roles
 
-## Application Components Breakdown
+The ExpressoTS application architecture is predicated on several pivotal components:
 
-| Component    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| DTO IN / OUT | Data transfer object that defines the format of the incoming and outgoing payload of the application.                                                                                                                                                                                                                                                                                                                                                      |
-| Controller   | Component responsible for processing requests and responses based on the URL and HTTP method. It also validates the conformity of the incoming data.                                                                                                                                                                                                                                                                                                       |
-| Use Case     | Component responsible for implementing the logic required to handle requests received from the controller. When the controller receives an HTTP request and validates the incoming data, it triggers the relevant use case, passing along the validated data for processing. The use case performs the necessary operations based on the request and returns the appropriate response to the controller, which then sends the response back to the client. |
-| Provider     | Component responsible for providing external functionality to the application.                                                                                                                                                                                                                                                                                                                                                                             |
-| Repository   | Component responsible for providing layer of communication with the database. Facilitating connection and CRUD operations.                                                                                                                                                                                                                                                                                                                                 |
+-   **DTO IN/OUT**: Defines the structure for incoming and outgoing data, ensuring type safety and consistency across the application.
+-   **Controller**: Manages request processing, routing based on URL and HTTP method, and data validation.
+-   **Use Case**: Executes specific logic for handling requests, acting upon validated data from controllers to perform operations and return responses.
+-   **Provider**: Supplies external functionalities like database access, email services, or authentication mechanisms.
+-   **Repository**: Facilitates direct communication with the database for CRUD operations, abstracting the data layer.
 
 :::info
 Providers and Repositories are optional components. You can use them if you need to provide extra functionality to your application such as database integration, logging system, authentication, email etc.
 :::
 
-## Workflow
+## Application workflow
 
-The workflow of an ExpressoTS application is straightforward, as shown in the diagram above.
-
-1. After initializing the application with all its components, including the container, modules, and controllers, the server starts listening for incoming requests.
-2. When a request is received, the server looks for the corresponding route and executes the associated controller, which typically exposes endpoints.
-3. The controller then calls the relevant use-case, which in turn calls the appropriate provider when required. Providers are external components that offer additional functionality to the application.
+The workflow begins with the server initialization, including setting up the container, modules, and controllers. Upon receiving requests, the server invokes the relevant controller, which then triggers the corresponding use case. If needed, use cases interact with providers to access external resources or services.
 
 :::warning Initializing the Application without a controller
 ExpressoTS will prevent you from initializing the Application without a controller since there are no listeners to handle incoming requests. You will see the following message in the console:
 **_No controllers have been found! Please ensure that you have register at least one Controller._**
 :::
 
-## AppExpress Class
-
-The AppExpress class offers a way to create and configure the server, passing **[Express.js middlewares](https://expressjs.com/en/guide/writing-middleware.html)** or other middleware upon server creation.
-
-To create an ExpressoTS application instance, we use the `AppFactory` class, which is responsible for creating the application instance and initializing the container, modules, and controllers. The `create()` function returns an IApplicationExpress which provides a set of methods to configure the server, including the `listen()` method, which starts the server and listens for incoming requests and `setEngine()`.
+## AppExpress class
 
-### AppExpress Class Definition
+The AppExpress class offers a way to create and configure the server, passing **[Express.js middlewares](https://expressjs.com/en/guide/writing-middleware.html)**, register external providers, and set up the server environment. The AppExpress class provides three lifecycle hooks that allow developers to execute code before, after, and on server shutdown. The following is the AppExpress class structure:
 
 ```typescript
-class AppExpress {
-  /**
-   * Configure services that should be initialized before the server starts.
-   */
-  protected configureServices(): void {}
-
-  /**
-   * Configure services that should be executed after the server starts.
-   */
-  protected postServerInitialization(): void {}
-
-  /**
-   * Perform actions or cleanup after the server is shutdown.
-   */
-  protected serverShutdown(): void {}
-
-  public async create() {}
-
-  public async listen() {}
-}
-```
-
-Also, in the application provider that inherits from AppExpress user can perform conditional logic based on the server environment mechanic provided `isDevelopment()`.
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
 
-```typescript
-if (this.isDevelopment()) {
-  // your logic here
-}
-```
+    protected configureServices(): void {
+        this.provider.register(Env);
 
-### Create Method
+        this.middleware.addBodyParser();
+        this.middleware.setErrorHandler();
+    }
 
-The create method allows developers to pass the container, middlewares and http server adapters to the server. To pass middleware you don't need to use `app.use()`, just pass the middleware and its configuration as demonstrated below:
+    protected postServerInitialization(): void {
+        if (this.isDevelopment()) {
+            this.provider.get(Env).checkAll();
+        }
+    }
 
-```typescript
-async function Bootstrap() {
-  await AppFactory.create(container, [
-    express.json(),
-    express.urlencoded({ extended: true }),
-    cors({
-      origin: "*",
-    }),
-  ]);
+    protected serverShutdown(): void {}
 }
 ```
 
 :::info
-Adapters are used to create the server. Currently, Express is the only adapter available. Fastify adapter is a work-in-progress.
-When you create an application instance, you can pass the adapter as the third parameter. If you don't pass the adapter, Express is used by default.
+The `App` class offers a set of out-of-the-box middlewares and providers that can be used to configure your application. See the complete list in the **[Middleware section](./middleware.md)**
 :::
 
-### Listen Method
+## Application bootstrapping
 
-The `listen()` method starts the server and listens for incoming requests. In the listen method, developers can define the port number and server environment, which can be either development, staging, or production. Developers can also set the application name and version to be displayed in the console when the server starts, as shown in the following example:
+The application bootstrapping process involves creating the server, passing the container, the App class, and starting the server. The AppFactory class provides the create and listen method that allows developers to create the server and listen for incoming requests. The following is the Bootstrap function that creates the server:
 
 ```typescript
-// App listen method
-app.listen(3000, ServerEnvironment.Development, {
-  appName: "Your App Name",
-  appVersion: "v1.0.0",
-});
-```
-
-:::tip
-The name and version of your app can be configured via either the .env file or package.json file. In the opinionated template, we use the package.json file to retrieve the app name and version.
-:::
-
-### Server Environment Enum
-
-This is an enum that defines the server environment. Currently supported environments are `development` and `production`. Upon server initialization, the underlying framework will look for the NODE_ENV environment variable and set the server environment accordingly. If the NODE_ENV environment variable is not set, the server environment will be set to development by default.
-
-Here are the enum values available for server environments:
-
-```typescript
-{
-  ServerEnvironment.Development;
-  ServerEnvironment.Production;
-}
-```
-
-## App Class Provider
-
-The App class provider is the heart of the `opinionated template` application. It is responsible for initializing the application and provide functionalities to be configured in the server bootstrapping process. You can make use of the built-in middlewares and providers to configure your application.
-
-```typescript
-class App extends AppExpress {
-  private middleware: IMiddleware;
-  private provider: IProvider;
-
-  constructor() {
-    super();
-    this.middleware = container.get<IMiddleware>(Middleware);
-    this.provider = container.get<IProvider>(Provider);
-  }
-
-  protected configureServices(): void {
-    this.middleware.addBodyParser();
-    this.middleware.setErrorHandler();
-  }
-
-  protected postServerInitialization(): void {
-    if (this.isDevelopment()) {
-      this.provider.envValidator.checkAll();
-    }
-  }
-
-  protected serverShutdown(): void {}
+async function bootstrap() {
+    const app = await AppFactory.create(container, App);
+    await app.listen(3000, ServerEnvironment.Development);
 }
 ```
 
-The App class provider offers a set of out-of-the-box middlewares and providers that can be used to configure your application. Here is a list of the available middlewares and providers:
-
-### Middlewares
-
-Here are some of the middlewares available:
-
-| Middleware Name  | Description                                       |
-| ---------------- | ------------------------------------------------- |
-| addBodyParser    | Add body parser middleware to the application.    |
-| addCompression   | Add compression middleware to the application.    |
-| addCors          | Add cors middleware to the application.           |
-| addHelmet        | Add helmet middleware to the application.         |
-| addCookieParser  | Add cookie parser middleware to the application.  |
-| addCookieSession | Add cookie session middleware to the application. |
-| addSession       | Add session middleware to the application.        |
-| addServerStatic  | Add static middleware to the application.         |
-| addRateLimit     | Add rate limit middleware to the application.     |
-| addMorgan        | Add morgan middleware to the application.         |
-| addPassport      | Add passport middleware to the application.       |
-| setMulter        | Add multer middleware to the application.         |
-| addServeFavicon  | Add serve favicon middleware to the application.  |
-| setErrorHandler  | Add error handler middleware to the application.  |
+:::info
+The framework currently supports Express as its primary adapter, with Fastify and other possible in house server under development.
+:::
 
-### Providers
+### Environment management
 
-Here are some of the providers available:
+The server environment is defined through the `ServerEnvironment` enum, with support for `development` and `production` modes, defaulting to development if `NODE_ENV` is unset.
 
-| Provider Name | Description                         |
-| ------------- | ----------------------------------- |
-| envValidator  | Validate the environment variables. |
-| logger        | Add logger to the application.      |
+-   ServerEnvironment.Development;
+-   ServerEnvironment.Production;
 
-## App Class Lifecycle Hooks
+## Application lifecycle hooks
 
-Another important aspect of the Application class is lifecycle hooks. These hooks allow developers to execute code before, after and on server shutdown. It is important to note that in order to take advantage of these hooks, developers must create an App class extending the Application class and override the methods as needed. The following example shows the life cycle hooks available at the moment:
+Another important aspect of the Application class is lifecycle hooks. These hooks allow developers to execute code before, after and on server shutdown.
 
 ```typescript
     /* Add any service that you want to be initialized before the server starts */
@@ -217,27 +114,26 @@ Another important aspect of the Application class is lifecycle hooks. These hook
 
 ## Application Scripts
 
-Below are the scripts used to run, build and test your application.
-The command column shows NPM as the package manager, but you can use your package manager of choice.
+Scripts for building, running, and testing the application are provided, accommodating different development stages and operational needs, from development to production.
 
-| Script     | Description                                     | Command            |
-| ---------- | ----------------------------------------------- | ------------------ |
-| build      | Build the production bundle in a ./dist folder. | npm run build      |
-| dev        | Runs in development watch mode.                 | npm run dev        |
-| prod       | Runs in production mode based on built bundle.  | npm run prod       |
-| test       | Run your tests located in the test folder.      | npm run test       |
-| test:watch | Run your tests in watch and interactive mode.   | npm run test:watch |
-| test:cov   | Produces test coverage report.                  | npm run test:cov   |
-| format     | Format the code using prettier.                 | npm run format     |
-| lint       | Lint code using eslint.                         | npm run lint       |
+| Script               | Description                                     | Command            |
+| -------------------- | ----------------------------------------------- | ------------------ |
+| expressots run build | Build the production bundle in a ./dist folder. | npm run build      |
+| expressots run dev   | Runs in development watch mode.                 | npm run dev        |
+| expressots run prod  | Runs in production mode based on built bundle.  | npm run prod       |
+| test                 | Run your tests located in the test folder.      | npm run test       |
+| test:watch           | Run your tests in watch and interactive mode.   | npm run test:watch |
+| test:cov             | Produces test coverage report.                  | npm run test:cov   |
+| format               | Format the code using prettier.                 | npm run format     |
+| lint                 | Lint code using eslint.                         | npm run lint       |
 
-## Running the Application
+## Starting the application
 
 ```bash
 npm run dev
 ```
 
-Depending on which environment you are running the application in, you will see the following message in the console:
+This will start the application with console output indicating the version, running port, and environment, providing clear feedback on the application's running state.
 
 `expressots-demo version 1.0.0 is running on port 3000 - Environment: development`
 
@@ -247,9 +143,9 @@ Depending on which environment you are running the application in, you will see
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/overview/first-steps.md b/docs/overview/first-steps.md
index 478768c2..475ef15e 100644
--- a/docs/overview/first-steps.md
+++ b/docs/overview/first-steps.md
@@ -2,25 +2,13 @@
 sidebar_position: 1
 ---
 
-# First Steps
+# First steps
 
-In this section, you will delve into the core concepts of ExpressoTS to familiarize yourself with the framework and its building blocks.
-
-## The technology
-
-We believe in the power of strongly typed languages, and **[TypeScript](https://www.typescriptlang.org/)** is essential when it comes to structuring or building large-scale applications in **[NodeJS](https://nodejs.org/)**. In the following example we will mostly use TypeScript.
+Begin your journey with ExpressoTS, a TypeScript framework for building scalable and maintainable Node.js applications. This section guides you through the foundational concepts, setup, and architecture of ExpressoTS.
 
 ## Why TypeScript?
 
--   Improved code quality: Strong typing helps to catch errors and bugs at compile time, rather than at runtime, which helps to improve the overall quality of the code. This can lead to fewer crashes and issues with the code in production.
-
--   Better scalability: Strong typing can help make code more scalable by allowing for easier refactoring and maintenance. This is because strong typing ensures that changes to the code are consistent and predictable, making it easier to add new features or modify existing ones.
-
--   Increased productivity: Strong typing can increase developer productivity by providing better tooling and editor support, such as code completion, type inference, and automatic refactoring. This can help developers write code faster and with fewer errors.
-
--   Improved collaboration: Strong typing can make it easier for developers to collaborate by providing a shared understanding of the types and interfaces used in the codebase. This can help reduce misunderstandings and inconsistencies and make it easier for developers to work together on the same codebase.
-
--   Better documentation: Strong typing can help make code more self-documenting by providing a clear and concise description of the types and interfaces used in the code. This can help reduce the need for extensive comments and documentation, making the code easier to understand and maintain.
+**[TypeScript](https://www.typescriptlang.org/)** is a key element in developing robust server-side applications due to its strong typing, which significantly enhances code quality, scalability, productivity, and collaboration. Strong typing not only helps in catching errors early but also improves code documentation and maintainability, making TypeScript an excellent choice for large-scale applications.
 
 ## Pre-requisites
 
@@ -28,35 +16,34 @@ Please make sure that [Node.js](https://nodejs.org) `version >=18.10.0` is insta
 
 ## Setup
 
+Install the **[ExpressoTS CLI](../cli/overview.md)** globally using NPM to get started with your project setup:
+
 Setting up a new ExpressoTS project is quite simple with **[ExpressoTS CLI](../cli/overview.md)**. First install the CLI globally with `NPM`:
 
 ```bash
 npm i -g @expressots/cli
 ```
 
-With `expressots` CLI you can create a new project by running the following command:
+Create a new project by running:
 
 ```bash
 expressots new <project-name>
 ```
 
-Or adding template name and package manager as arguments:
+For a specific project structure and package manager, specify the template and package manager directly:
 
 ```bash
-expressots new <project-name> -t <template-name> -p <package-manager>
+expressots new <project-name>  -p <package-manager> -t <template-name>
 ```
 
-:::tip
-ExpressoTS offers two options for project templates:
-
--   Non-opinionated: Want to have the liberty to build and structure your project as you wish? Non opinionated template offers a very small footprint, with only the necessary files to get you started.
--   Opinionated: Opinionated template is made for more complex projects, as it provides a more layered architecture.
+## Project templates
 
-:::
+ExpressoTS provides two project templates to cater to different development needs:
 
-After creating your project, with the desired `<project-name>`, and depending on the project template you have selected, your project will have a different folder and file structure. Here are the specific folder and file structures for each project template:
+-   Non-opinionated: Offers flexibility in project structuring with minimal setup.
+-   Opinionated: Comes pre-configured for complex projects, reinforcing a specific project structure and scaffolding pattern.
 
-### Non-opinionated project template
+### Non-opinionated project structure
 
 ```tree
 project-name/
@@ -64,62 +51,34 @@ project-name/
 │   ├── app.container.ts
 │   ├── app.controller.ts
 │   ├── app.module.ts
-│   ├── app.usecase.ts
+│   ├── app.provider.ts
 │   ├── main.ts
 ├── test/
-│   ├── app.usecase.spec.ts
+│   ├── app.controller.spec.ts
 ```
 
-| File Name             | Description                                                                                                           |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `app.container.ts`    | The Inversify Server container is responsible for organizing all the modules of the application into a cohesive unit. |
-| `app.controller.ts`   | A basic controller with a single route.                                                                               |
-| `app.module.ts`       | Application root module.                                                                                              |
-| `app.usecase.ts`      | A basic use case with a single method, called `execute()`.                                                            |
-| `main.ts`             | The main entry point of an ExpressoTS application.                                                                    |
-| `app.usecase.spec.ts` | A basic unit test for the app.usecase.                                                                                |
-
-### Opinionated project template
+| File Name                | Description                                                        |
+| ------------------------ | ------------------------------------------------------------------ |
+| `app.container.ts`       | Dependency injection container. Organizes the application modules. |
+| `app.controller.ts`      | A basic controller with a single route.                            |
+| `app.module.ts`          | Application root module.                                           |
+| `app.provider.ts`        | Application lifecycle manager.                                     |
+| `main.ts`                | The main entry point of an ExpressoTS application.                 |
+| `app.controller.spec.ts` | Unit test for the app.controller.                                  |
 
-In the opinionated project template we provide a full CRUD example for a user entity, with all the necessary layers and files to get you started.
+### Opinionated project structure
 
 ```tree
 project-name/
 ├── src/
-│   ├── entities/
-│   │   └── base.entity.ts
-│   │   └── user.entity.ts
 │   ├── providers/
-│   │   └── application/
-│   │       └── application.provider.ts
-│   ├── repositories/
-│   │   └── user/
-│   │       └── user-repository.ts
-│   │   └── base-repository.interface.ts
-│   │   └── base-repository.ts
+│   │   └── app/
+│   │       └── app.provider.ts
 │   ├── useCases/
 │   │   └── app/
 │   │       └── app.controller.ts
 │   │       └── app.module.ts
 │   │       └── app.usecase.ts
-│   │   └── user/
-│   │       └── create/
-│   │           └── user-create.controller.ts
-│   │           └── user-create.dto.ts
-│   │           └── user-create.usecase.ts
-|   │       └── delete/
-│   │           └── user-delete.controller.ts
-│   │           └── user-delete.dto.ts
-│   │           └── user-delete.usecase.ts
-│   │       └── find/
-│   │           └── user-find.controller.ts
-│   │           └── user-find.dto.ts
-│   │           └── user-find.usecase.ts
-│   │       └── findall/
-│   │           └── user-findall.controller.ts
-│   │           └── user-findall.dto.ts
-│   │           └── user-findall.usecase.ts
-│   │       └── user.module.ts
 │   ├── app.container.ts
 │   ├── env.ts
 │   ├── main.ts
@@ -129,168 +88,40 @@ project-name/
 
 | File Name             | Description                                                                                                           |
 | --------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `entities/`           | This folder contains class definitions, or models with their attributes, properties and methods.                      |
 | `providers/`          | This folder contains the layer responsible to provide externals resources to the application, also known as adapters. |
-| `repositories/`       | Additional folder containing an example of repository pattern implementation, database layer communication.           |
+| `app/app.provider.ts` | Application lifecycle manager.                                                                                        |
 | `useCases/`           | The use case folder contains the use cases implementation of operations that can be performed in the application.     |
-| `app.container.ts`    | The Inversify Server container is responsible for organizing all the modules of the application into a cohesive unit. |
+| `app.container.ts`    | Dependency injection container. Organizes the application modules.                                                    |
 | `env.ts`              | This is an utility resource that maps .env variables.                                                                 |
 | `main.ts`             | The main entry point of an ExpressoTS application.                                                                    |
 | `app.usecase.spec.ts` | A basic unit test for the app.usecase.                                                                                |
 
-Below you can find some extra information about **[Providers](./providers.md)**, **[Use Cases](./usecase.md)** and the **[Main](./application.md)** entry point of an ExpressoTS application used in the Opinionated template.
-
-#### Providers
-
-Contain 2 providers:
-
--   application: This provider is a class that extend from the Application class from @expressots/core that provides the application **[Life Cycle Hooks](application.md#lifecycle-hooks)**.
-
--   db-in-memory: This is a simple in-memory database provider that allows you to store data in memory. We use this provider in the User use cases to store and retrieve user data.
-
-:::info
-InMemoryDB provider is an example supplied to help you prototype endpoints quickly without having to worry about setting up a database. It is not intended to be used in production. You can replace it with your own database provider.
-:::
-
-#### Use cases
-
-The use cases in the Opinionated template are organized in 2 modules:
-
--   AppModule and UserModule, providing some examples of usage of the ExpressoTS resources. For more information about modules, please check the **[Modules Section](./module.md)**.
-
-Here are the endpoints in each module:
-
--   [AppModule]/app.controller: returns `Hello from ExpressoTS App`
--   [UserModule]/user-create.controller: creates a new user in the in-memory database
--   [UserModule]/user-delete.controller: delete a user by `id` in the in-memory database
--   [UserModule]/user-find.controller: return one user from the in-memory database
--   [UserModule]/user-findall.controller: returns all users from the in-memory database
--   [UserModule]/user-update.controller: update a user info from the in-memory database
-
-#### Main
-
-The `main.ts` includes an async function that will bootstrap the ExpressoTS application.
-
-##### Opinionated in its simple form
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, App);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-##### Non opinionated
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, []);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-## AppExpress or Middleware
-
-To bootstrap an ExpressoTS application, there are two ways:
-
--   Non-opinionated template using the AppFactory to creates an instance of the default ExpressoTS adapter which is the Express.js. User can directly pass an array of middleware to the `AppFactory.create` method, which will be responsible for creating an Expressjs application with the provided middleware. This method of creating an ExpressoTS application exposes the Expressjs application instance, which can be used to add additional middleware or to configure the Expressjs application.
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, [cors(), helmet()]);
-    await app.listen(3000, ServerEnvironment.Development);
-}
+This structure provides a robust framework for developing API endpoints, showcasing the layering and organization capabilities of ExpressoTS.
 
-bootstrap();
-```
+## Application initialization and Configuration
 
--   Opinionated template using the AppFactory to create an AppExpress application. By using the App (AppExpress) class, you can take advantage of its built-in mechanisms for controlling the **[application life cycle hooks](application.md#application-lifecycle-hooks)**, such as injecting and executing services before, after, and during application shutdown.
+Initialize your application with the `AppFactory.create()` method, passing in the container and an App class for lifecycle management. This step is crucial for configuring your application's dependency injection and middleware setup.
 
 ```typescript
 async function bootstrap() {
     const app = await AppFactory.create(container, App);
     await app.listen(3000, ServerEnvironment.Development);
 }
-
-bootstrap();
 ```
 
-## The container
+## Running your application
 
-In ExpressoTS, creating an application server to listen to inbound HTTP requests is not enough. The framework requires the creation of a container that organizes all application modules into a cohesive unit. Typically, this container is created in the `app.container.ts` file. The container is responsible for managing the application's dependencies. Read more about the `app.container` in the **[App Container](app-container.md)** section.
-
-### Application uses the container
-
-After the container is created in the `app.container` file, the application can be created by passing the container as a parameter to the `AppFactory.create` method:
-
-```typescript
-AppFactory.create(container);
-```
-
-### Injecting modules in the container
-
-Once the container is created, modules can be injected into the application. These modules are the building blocks of an ExpressoTS application and are responsible for organizing the application's business logic into layers, as a module is a group of functionalities or endpoints also called `controllers`.
-Read more about the modules in the **[Modules](module.md)** section.
-
-```typescript
-const appContainer = new AppContainer();
-
-const container: Container = appContainer.create([
-    // Add your modules here
-    AppModule,
-]);
-```
+With your application set up, start your development server or build your application with the following commands:
 
-### Injecting controllers in the modules
-
-The controller layer handles incoming requests and returns appropriate responses, they are the entry point of the application for each endpoint. Read more about the controllers in the **[Controllers](controller.md)** section. In order to make a controller functional, it must be injected into a module. This can be done by passing the controller as a parameter to any module. As an example, the following code snippet demonstrates how to inject a controller into AppModule:
-
-```typescript
-const AppModule: ContainerModule = CreateModule([
-    // Add your controllers here
-    AppController,
-]);
-```
-
-### Fully hooked-up application flow
-
-After creating a module, the module can be added in the container, and after creating controllers, controllers can be injected into the module, resulting in a fully hooked-up application flow.
+-   Development Mode: `npm run dev`
+-   Production Build: `npm run build`
+-   Production Mode: `npm run prod`
 
 :::info
-It is worth noting that a project created with the ExpressoTS CLI comes with an initial project structure that promotes adherence to a specific convention set by the framework. This ensures that each module has its own dedicated directory, helping developers maintain consistency throughout their codebase.
-:::
-
-## Running the application
-
-Once the installation process is complete, you can start listening to HTTP requests based on the defined controller endpoint that will invoke the corresponding use case to generate the response. To do this, simply run the following command in your OS terminal:
-
-### Running in development mode
-
-```bash
-npm run dev
-```
-
-### Building the production bundle
-
-```bash
-npm run build
-```
-
-### Running the production bundle
-
-```bash
-npm run prod
-```
-
-:::tip
 Once the application is up and running, you can access it by navigating to `http://localhost:3000/`.
 :::
 
-## Note
+## Framework flexibility
 
 ExpressoTS is a versatile framework that is not bound to any specific platform or technology. Leveraging popular Node.js libraries like InversifyJS and Express.js, it is designed to be lightweight, modular, customizable, and easy to use. Developers can expand the framework's capabilities by creating new providers that can be incorporated into their applications.
 
diff --git a/docs/overview/img/container-bindings.png b/docs/overview/img/container-bindings.png
new file mode 100644
index 00000000..cf35a7ca
Binary files /dev/null and b/docs/overview/img/container-bindings.png differ
diff --git a/docs/overview/img/middleware-view.png b/docs/overview/img/middleware-view.png
new file mode 100644
index 00000000..8413b839
Binary files /dev/null and b/docs/overview/img/middleware-view.png differ
diff --git a/docs/overview/img/plugin-pattern.png b/docs/overview/img/plugin-pattern.png
new file mode 100644
index 00000000..1d4819e5
Binary files /dev/null and b/docs/overview/img/plugin-pattern.png differ
diff --git a/docs/overview/img/scaffold-resources.png b/docs/overview/img/scaffold-resources.png
new file mode 100644
index 00000000..f7af925e
Binary files /dev/null and b/docs/overview/img/scaffold-resources.png differ
diff --git a/docs/overview/intro.md b/docs/overview/intro.md
index d3780fe1..a3eccdbf 100644
--- a/docs/overview/intro.md
+++ b/docs/overview/intro.md
@@ -4,69 +4,65 @@ sidebar_position: 0
 
 # Introduction
 
-ExpressoTS is a lightweight framework for building scalable, readable and maintainable server-side applications in TypeScript.
-The framework provides a level of abstraction on top of a common HTTP server framework **[Express.js](https://expressjs.com/)**, exposing their API's directly to the developer. This provides freedom and brings to the developer a tool that is well known and easy to use.
+ExpressoTS offers a refined layer over **[Express.js](https://expressjs.com/)**, enhancing server-side TypeScript application development. It blends the robustness of Express.js with advanced TypeScript features, streamlining the creation of scalable, maintainable, and readable applications.
 
 ## Philosophy
 
-ExpressoTS is a developer-friendly framework designed to streamline the process of building server-side applications. It aims to simplify the development process by providing a clear and concise structure.
+Designed for efficiency, ExpressoTS simplifies server-side development. It reduces boilerplate, focusing on code clarity and structure. The framework's flexibility, through a comprehensive **[Dependency Injection system](./di.md)**, supports seamless integration of custom features with predefined scopes (Transient, Scoped, Singleton), fostering modular and decoupled design.
+Whether for a straightforward API or an intricate enterprise system, ExpressoTS accelerates development, ensuring timely, within-budget delivery of high-quality applications.
 
-With ExpressoTS, developers can focus on what really matters - writing code. The framework takes care of the repetitive and time-consuming aspects of development, allowing developers to work more efficiently.
+## Setup
 
-One of the key features of ExpressoTS is its flexible and extensible architecture. The framework provides a robust **[Dependency Injection](di.md)** system that enables developers to extend its functionality by creating and adding providers with their specific binding scope such as `Transient, Scoped, Singleton`. This allows developers to integrate new features throughout the application without having to worry about the complexities of integration and coupling.
+### Installation
 
-Whether you're building a simple API or a complex enterprise application, ExpressoTS can help you deliver your project on time and on budget. With a comprehensive set of tools and features, ExpressoTS makes it easy to build high-quality, scalable, and maintainable server-side applications.
-
-## Installing the CLI
-
-Before creating a project make sure you have ExpressoTS CLI installed globally on your machine.
+Install the ExpressoTS CLI Globally:
 
 ```bash
 npm i -g @expressots/cli
 ```
 
-## Creating a New Project
+### Project Initialization
 
-To create a project using the CLI, run the following commands.
+Create a new project using the CLI:
 
 ```bash
 expressots new <project-name>
 ```
 
-The CLI will prompt you with a few questions and then create a new project directory with the name you provide, along with the @expressots/core package and a starter project structure. Or you can create projects without the CLI questions by passing the template name (`opinionated` or `non-opinionated`) and the package manager (`npm`, `yarn` or `pnpm`) as arguments.
+For a quick setup, specify the project template and package manager directly:
 
 ```bash
-expressots new <project-name> -t <template-name> -p <package-manager>
+expressots new <project-name> -p <package-manager> -t <template-name>
 ```
 
-## Project Types or Templates
+## Project Templates
 
 ExpressoTS offers two starter project templates: `opinionated` and `non-opinionated`.
 
-- Use the `non-opinionated` starter project template when you need flexibility on your project structure.
-- Choose the `opinionated` starter project template for more complex projects with a complete starting point.
+-   `non-opinionated`: Offers structural flexibility.
+-   `opinionated`: Provides a comprehensive project structure with predefined scaffold schematics.
 
-### Accessing Your Project
+## Development Workflow
 
-After creating your project you can access it by running the following command:
+### Access your project
 
 ```bash
 cd <your-project-name>
 ```
 
-### Running in Development Mode
+### Development Mode
 
 ```bash
 npm run dev
 ```
 
-### Generating a Production Build
+### Production Build
 
 ```bash
 npm run build
 ```
 
-### Running in Production Mode
+### Production Mode
 
 ```bash
 npm run prod
@@ -78,9 +74,9 @@ npm run prod
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a sponsor on **[Sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a sponsor on **[Sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/overview/middleware.md b/docs/overview/middleware.md
index ec27a925..96f2e86e 100644
--- a/docs/overview/middleware.md
+++ b/docs/overview/middleware.md
@@ -4,21 +4,36 @@ sidebar_position: 5
 
 # Middleware
 
-Middleware is a function that has access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. The next middleware function is commonly denoted by a variable named next.
+Middleware functions are pivotal in the request-response cycle of an ExpressoTS application, providing the capability to execute code, modify request and response objects, end the request-response cycle, or call the next middleware in the stack. It's essential to call next() to avoid request timeouts unless your middleware concludes the cycle.
 
-Middleware can:
-
--   Run code.
--   Modify request and response objects.
--   Conclude the request-response process.
--   Proceed to the next middleware in the sequence.
--   Ensure to invoke next() if the middleware does not close the request-response loop to avoid stalling the request.
+ExpressoTS seamlessly integrates with Express middleware, enabling the use of its extensive ecosystem to enhance your application.
 
 :::info
-ExpressoTS fully supports [Express](https://expressjs.com/) middleware.
+ExpressoTS fully supports [Express](https://expressjs.com/en/resources/middleware.html) middleware.
 :::
 
-## Adding Middleware
+## List of middlewares available
+
+Expressjs middlewares supported by ExpressoTS:
+
+| Middleware Name  | Description                                       |
+| ---------------- | ------------------------------------------------- |
+| addBodyParser    | Add body parser middleware to the application.    |
+| addCompression   | Add compression middleware to the application.    |
+| addCors          | Add cors middleware to the application.           |
+| addHelmet        | Add helmet middleware to the application.         |
+| addCookieParser  | Add cookie parser middleware to the application.  |
+| addCookieSession | Add cookie session middleware to the application. |
+| addSession       | Add session middleware to the application.        |
+| addServerStatic  | Add static middleware to the application.         |
+| addRateLimit     | Add rate limit middleware to the application.     |
+| addMorgan        | Add morgan middleware to the application.         |
+| addPassport      | Add passport middleware to the application.       |
+| setMulter        | Add multer middleware to the application.         |
+| addServeFavicon  | Add serve favicon middleware to the application.  |
+| setErrorHandler  | Add error handler middleware to the application.  |
+
+## Adding middleware
 
 ExpressoTS application supports adding middleware globally to the application as well as per route. It offers all the [middleware supported by Express Team](https://expressjs.com/en/resources/middleware.html) out-of-the-box through the use of `this.middleware` property.
 
@@ -44,7 +59,7 @@ export class App extends AppExpress {
 If you add a middleware that is not installed as dependency, the application will throw a warning message and continue to run.
 :::
 
-### Global Middleware
+## Adding global middleware
 
 Middlewares can be added globally using the `App` class through the `this.middleware` property, using the out-of-the-box middleware list provided by Express Team:
 
@@ -56,6 +71,8 @@ protected configureServices(): void {
     }
 ```
 
+## Using `addMiddleware` method
+
 For any other middleware, or a custom middleware, you can add it using the `this.middleware.addMiddleware()` method. Using the `addMiddleware` method, you can add any middleware from NPM Registry, custom Expressjs middleware or a custom ExpressoTS middleware.
 
 NPM Registry middleware:
@@ -64,7 +81,7 @@ NPM Registry middleware:
 this.middleware.addMiddleware(cors());
 ```
 
-Custom Expressjs middleware:
+### Creating expressjs middleware
 
 ```typescript
 function myMiddleware(req: Request, res: Response, next: NextFunction) {
@@ -77,6 +94,8 @@ function myMiddleware(req: Request, res: Response, next: NextFunction) {
 this.middleware.addMiddleware(myMiddleware);
 ```
 
+### Creating expressots middleware
+
 Custom ExpressoTS middleware:
 
 ```typescript
@@ -92,7 +111,7 @@ class CustomMiddleware extends ExpressoMiddleware {
 this.middleware.addMiddleware(new CustomMiddleware());
 ```
 
-### Route Middleware
+## Route Middleware
 
 Middlewares can be added per route in the `App` class through the `this.middleware.addMiddleware()` method. You can add any middleware from NPM Registry, custom Expressjs middleware or a custom ExpressoTS middleware.
 
@@ -104,6 +123,8 @@ this.middleware.addMiddleware({ path: "/api", middlewares: [] });
 Each route can have multiple middlewares.
 :::
 
+### Adding middleware to a specific route
+
 Or you add a middleware to a specific route in the `Controller` class through the `@controller()` and/Or `http Method` decorators.
 
 ```typescript
@@ -116,6 +137,8 @@ export class AppController {
 }
 ```
 
+### Adding middleware to all routes in a controller
+
 If you want to apply a middleware to all routes under a specific controller, you can add it to the `@controller()` decorator.
 
 ```typescript
@@ -133,7 +156,7 @@ export class AppController {
 }
 ```
 
-## Creating Custom ExpressoTS Middleware
+## Example of custom expressoTS middleware
 
 To create a custom middleware, you need to extend the `ExpressoMiddleware` class and implement the `use` method.
 
@@ -159,14 +182,19 @@ class CustomMiddleware extends ExpressoMiddleware {
 
 Custom middleware allows you to pass parameters to the constructor and use them as options in the `use` method of your middleware.
 
-:::tip
-Use ExpressoTS CLI to scaffold a custom middleware.
+## View all middlewares pipeline
+
+You can view all the middlewares added to the application using the `this.middleware.viewMiddlewarePipeline()` method.
+
+![View Middleware Pipeline](./img/middleware-view.png)
+
+:::tip Use ExpressoTS CLI to scaffold a custom middleware.
 :::
 
 CLI command to scaffold a custom middleware:
 
 ```bash
-expressots g m <<middleware-name>>
+expressots g mi <<middleware-name>>
 ```
 
 ---
diff --git a/docs/overview/module.md b/docs/overview/module.md
index cc7cf7f5..21676415 100644
--- a/docs/overview/module.md
+++ b/docs/overview/module.md
@@ -4,56 +4,39 @@ sidebar_position: 4
 
 # Modules
 
-A module or container module is a collection of services, in our case more specifically `Controllers` and their dependencies that can be registered and resolved by ExpressoTS custom InversifyJS container wrapper.
+Modules, or container modules in ExpressoTS, are aggregations of services—primarily Controllers and their dependencies—that are managed by the framework's container. These modules facilitate the organization, registration, and resolution of various application components within the ExpressoTS ecosystem.
 
-A container module is a class that exports an Inversify Module object, which is essentially a configuration object that defines the bindings for the controllers. The Module object has a bind method that allows you to define bindings between services and their dependencies.
+## Understanding modules
 
-In order to fully understand how you can register your classes, such as usecases, entities, providers, repositories, helpers, etc, please read the **[Dependency Injection](di.md)** section. Essentially we have a group of decorators that overrides the default Container scope.
+A module exports an Inversify Module object, serving as a configuration entity for controller bindings and their dependencies. It utilizes a bind method to establish relationships between services and their dependencies. To grasp the registration of classes such as use cases, entities, providers, repositories, and more, delve into the **[Dependency Injection section](./di.md)**, which elaborates on decorators influencing the default container scope.
 
-## Module or container module
+## Simplifying bindings with `CreateModule`
 
-With ExpressoTS you don't have to worry about doing bindings manually, we created a helper function called `CreateModule` that receives an array of controllers and returns a module with all the controllers registered and their dependencies injected.
-
-## Module Container
-
-A container module is typically used to group related controllers and their dependencies together, making it easier to register and manage them in the container. For example, you could create a container module that defines the bindings for a set of data access controllers, or a set of business logic services.
-
-Once a container module has been defined, it can be loaded into the `AppContainer` using the `appContainer.create()` method, which takes the container module class as an argument. Refer to the **[App container](app-container.md)** section for more information. This will register all services and dependencies defined in the module automatically, making them available for injection in other parts of your application.
-
-Container modules can be a powerful tool for managing large applications with complex dependency graphs, as they allow you to organize your code into smaller, more manageable pieces, and make it easier to reason about the relationships between different parts of the application.
-
-A container module or as we call simply module is defined in the example below:
+ExpressoTS simplifies the binding process through the `CreateModule` function. This utility auto-registers controllers, injecting their dependencies without manual binding:
 
 ```typescript
-const AppModule = CreateModule([
-    AppController,
-]);
-
-export { AppModule };
+export const AppModule: ContainerModule = CreateModule([AppController]);
 ```
 
-## Module scope
+## Defining module scope
 
 Very similar to the `Container`, developers can set the scope of a module using the same `BindingScopeEnum` enum. Here are the enum values:
 
-- `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
-- `BindingScopeEnum.Request` - The dependency will be created once per request.
-- `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
+-   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
+-   `BindingScopeEnum.Request` - The dependency will be created once per request.
+-   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
 
 When creating a module, you can pass the scope as a second argument to the `CreateModule` function. It is optional and if not provided, the default scope is acquired from the `AppContainer` which is `RequestScope`.
 
 ```typescript
-const AppModule = CreateModule(
-    [
-        AppController,
-    ],
-    BindingScopeEnum.Singleton,
-);
+export const AppModule: ContainerModule = CreateModule([AppController], BindingScopeEnum.Singleton);
 ```
 
-This is a very handy feature as allows developers to create modules with different scopes. For example, you can create a module with the `Singleton` scope and another module with the `Request` scope. This is very useful when you have a module that contains services that needs to be shared across all requests and another module that contains services that needs to be created once per request.
+This flexibility allows for tailored dependency management strategies, such as combining Singleton scope modules for shared services with Request scope modules for request-specific services.
+
+## Scope precedence
 
-Scope precedence is defined as follows: `AppContainer` scope > `Module` scope > `Controller` scope.
+The hierarchy of scope precedence is `AppContainer` > `Module` > `Controller`, ensuring a versatile and hierarchical approach to dependency scope management. This layered structure permits precise control over service instantiation and lifecycle across the entire application.
 
 ---
 
@@ -61,9 +44,9 @@ Scope precedence is defined as follows: `AppContainer` scope > `Module` scope >
 
 ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
 
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
+-   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
+-   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
+-   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
+-   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
+-   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
+-   Share the project with your friends and colleagues
diff --git a/docs/overview/providers.md b/docs/overview/providers.md
index 80511d14..fed3d727 100644
--- a/docs/overview/providers.md
+++ b/docs/overview/providers.md
@@ -4,37 +4,46 @@ sidebar_position: 8
 
 # Providers
 
-From the perspective of the ExpressoTS Architecture, `Providers` are responsible for supplying data and/or mechanics to the application, abstracting the details of how the data/mechanic is actually implemented. This abstraction aligned with the Dependency Injection Container enables the developer to easily switch between different data sources/providers without affecting the other parts of the application as they are decoupled.
+In ExpressoTS, providers serve as modular enhancements to an application, encapsulating specific functionalities such as email services, authentication mechanisms, or database connections. This encapsulation is essential for preserving a loosely coupled architecture, enabling seamless swapping or updating of these functionalities without affecting the overall system.
 
-Providers can be implemented as classes or functions, and typically make use of infrastructure components such as databases, web services, or file systems to actually retrieve or store data and perform other tasks. A provider's goal is to encapsulate all the details of these low-level components and present a simple, high-level interface to the rest of the system.
+## The role of providers
 
-## Provider goal
+Providers encapsulate the operations of infrastructure components such as databases, web services, and file systems, presenting a unified interface to the application. This setup not only simplifies the codebase but also enhances its testability, maintainability, and scalability.
 
-The goal of a Provider is to encapsulate all the details of the "replaceable" components and present a simple, high-level interface to the rest of the system.
+### Key advantages
 
-In the context of dependency injection, providers are used to decouple the creation and configuration of objects from their use, which allows for easier testing, maintainability, and scalability of the codebase. By using providers to manage dependencies, developers can avoid tightly coupling components together and instead focus on the high-level design of the system.
-
-Overall, providers are an important aspect of clean code because they help to promote loose coupling, maintainability, and flexibility in software systems.
+-   Promote loose coupling between application layers.
+-   Simplify the testing process by decoupling logic from specific implementations.
+-   Enhance code maintainability and flexibility, supporting easy swaps of underlying services.
 
 :::info
-ExpressoTS uses providers to extend the application capability by providing additional functionalities.
+ExpressoTS harnesses providers to augment application capabilities, facilitating functionalities like email dispatching, data storage, and more, without tying the application logic to specific implementations.
 :::
 
-## Example
+## Implementing a provider: An email service example
+
+Consider an application needing to send emails under various circumstances, such as user registration or password recovery. By implementing an email provider, ExpressoTS can send emails without directly interacting with the mailing service in the business logic.
 
-Let's take the example provided in the **[Use Case](usecase.md#example)** section.
+### Setting up the provider
 
-In this scenario, the user is attempting to log in to the system, and as per the specification, the user can attempt to input their credentials three times before the system locks their account. If the user's account is locked, the system dispatches an email to notify the user.
+First, run the CLI command to scaffold a new provider in your ExpressoTS project:
+
+```bash
+expressots g p mailtrap
+```
 
-The email functionality is provided by a provider, which is used by the use case to send the email to the user. This provider is injected into the use case constructor, allowing the developer to leverage the provider's public interfaces.
+The CLI will add the suffix `Provider` to the provider name, creating a new file in the `providers` directory. This file will contain the provider class, which you can then customize to suit your application's needs.
 
-One of the immediate benefits of using providers is that they facilitate easier testing, as the code is decoupled from the use cases, and a component can easily be replaced with another component that implements the same interface.
+Here is the default provider file generated by the CLI:
 
-### Provider implementation
+```typescript
+import { provide } from "inversify-binding-decorators";
 
-Here is an example of provider implementation in ExpressoTS for sending emails:
+@provide(MailTrapProvider)
+class MailTrapProvider {}
+```
 
-We are using **[Mailtrap](https://mailtrap.io/)** as our email provider and the nodemailer library to send emails.
+### Implementing the provider
 
 ```typescript
 import nodemailer from "nodemailer";
@@ -109,12 +118,11 @@ class MailTrapProvider {
 export { MailTrapProvider, EmailType };
 ```
 
-In this implementation there is an auxiliary private function and the single public interface called `sendEmail()` that is going to be used in the use case.
-The provider is injected in the constructor to be used by the use case.
+This `MailTrapProvider` abstracts the complexity of configuring and using nodemailer for email operations, providing a straightforward method sendEmail to send different types of emails.
 
-### Use case consuming the provider
+### Consuming the provider in a use case
 
-Here is the use case implementation making use of the provider:
+Here is the use case implementation making use of the mailtrap provider:
 
 ```typescript
 @provide(LoginUserUseCase)
@@ -138,7 +146,114 @@ class LoginUserUseCase {
 export { LoginUserUseCase };
 ```
 
-In the Use Case above we injected MailTrapProvider in the constructor making use of the ExpressoTS container. In the execute() method of the Use Case we are calling the `sendEmail()` method of the provider to send an email to the user in case of a non successful login.
+In this use case, the `MailTrapProvider` is injected through the constructor, leveraging ExpressoTS's dependency injection. This decouples the email sending process from the authentication logic, illustrating the provider's role in maintaining clean and maintainable code.
+
+## Available providers in ExpressoTS
+
+ExpressoTS offers built-in providers for common functionalities, further extending the application's capabilities:
+
+| Provider Name | Description                         |
+| ------------- | ----------------------------------- |
+| envValidator  | Validate the environment variables. |
+| logger        | Add logger to the application.      |
+
+Providers are essential for building scalable, maintainable applications with ExpressoTS, emphasizing clean architecture and separation of concerns.
+
+## Automatic registration with fluent decorators
+
+ExpressoTS facilitates the registration of providers in its dependency injection system through the use of fluent decorators:
+
+-   @provide
+-   @provideSingleton
+-   @provideTransient
+
+These decorators ensure that providers are automatically registered, streamlining their integration and reducing boilerplate.
+
+## Creating and registering an external provider
+
+ExpressoTS encourages extensibility through the use of external providers. Developers can create reusable packages, following the plugin design pattern, to introduce new functionalities into an ExpressoTS application. This is particularly useful for features that need to be shared across multiple projects or for integrating third-party services.
+
+### Creating an external provider
+
+An external provider should be a CommonJS package implementing the IProvider interface:
+
+```typescript
+import { IProvider } from "expressots";
+
+@injectable()
+class Logger implements IProvider {
+    log(message: string): void {
+        console.log(message);
+    }
+}
+```
+
+Interface `IProvider`:
+
+```typescript
+export interface IProvider {
+    name: string;
+    version: string;
+    author: string;
+    repo: string;
+}
+```
+
+Once the package is developed and published to the npm registry, it can be easily integrated into any ExpressoTS application.
+
+### Registering Providers at Runtime
+
+Providers are registered in the `App` class of an ExpressoTS application using the `ProviderManager`. The `@injectable` decorator from InversifyJS makes the provider available for registration and resolution within the app's dependency injection system.
+
+```typescript
+@provide(App)
+export class App extends AppExpress {
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void {
+        // Registering core and external providers
+        this.provider.register(Logger);
+    }
+
+    protected postServerInitialization(): void {}
+
+    protected serverShutdown(): void {}
+}
+```
+
+:::info
+By default provider registration binds the provider as request-scoped. To change the scope, use the `BindingScopeEnum`.
+:::
+
+Example of registering a provider as a singleton:
+
+```typescript
+this.provider.register(Logger, BindingScopeEnum.Singleton);
+```
+
+This process grants the flexibility to enhance the application at runtime by integrating additional providers, enabling dynamic scaling and extension of the application's capabilities.
+
+## Visualizing the plugin design pattern
+
+The diagram illustrates the ExpressoTS plugin design pattern, demonstrating how external providers are seamlessly integrated into the client application through the Provider Manager. It showcases the process of registering new providers and their respective lifecycle scopes, which can be singleton, request, or scoped.
+
+![Plugin Design Pattern](./img/plugin-pattern.png)
+
+## Recommendations for using external providers
+
+When developing external providers for ExpressoTS, consider the following best practices:
+
+-   **Interface Implementation**: Ensure that external providers conform to the IProvider interface for consistency.
+-   **Lifecycle Management**: Choose the appropriate scope for the provider based on its intended usage pattern.
+-   **Testing**: Thoroughly test providers in isolation before integrating them into the main application.
+-   **Documentation**: Provide detailed usage instructions and configuration options for the external provider.
+
+By adhering to these practices, developers can ensure that their external providers are robust, maintainable, and easily integrated into any ExpressoTS application.
 
 ---
 
diff --git a/docs/overview/repositories.md b/docs/overview/repositories.md
index bda341c5..090f5d83 100644
--- a/docs/overview/repositories.md
+++ b/docs/overview/repositories.md
@@ -4,47 +4,28 @@ sidebar_position: 9
 
 # Repositories
 
-In ExpressoTS, a repository class typically includes methods such as create, update, find, findOne, and delete, which correspond to common CRUD (Create, Read, Update, Delete) operations on the data store. These methods can be implemented using a database library or ORM (Object-Relational Mapping) tool such as **[TypeORM](https://typeorm.io/), [Prisma](https://www.prisma.io/), [Sequelize](https://sequelize.org/),** etc.
+The repository pattern in ExpressoTS provides an abstraction layer for data access, encapsulating CRUD (Create, Read, Update, Delete) operations within repository classes. These repositories act as intermediaries between the business logic and data mapping layers, using ORMs like **[TypeORM](https://typeorm.io/), [Prisma](https://www.prisma.io/) or [Sequelize](https://sequelize.org/)** to interact with the database.
 
-## The repository pattern
+## Understanding the repository pattern
 
-The repository pattern is a design pattern commonly used in software development that provides a way to abstract the data persistence layer of an application. In TypeScript, this pattern can be implemented using classes that represent repositories, which are responsible for retrieving, storing, updating, and deleting data from a data store, such as a database.
+A repository pattern is a design strategy that abstracts data persistence, allowing business logic to be agnostic of the underlying database technology or schema. ExpressoTS utilizes this pattern to facilitate maintainability and scalability.
 
-We do offer an example of how to implement a repository pattern in the opinionated template. You can find it directly in the **[repository](https://github.com/expressots/expressots/tree/main/templates/opinionated/src/repositories)** folder of the ExpressoTS application.
-
-## Goal of the repository pattern
+## Goals and benefits
 
 The main goal of the repository pattern is to separate business logic from data access logic. This allows developers to write code that is more focused on the business requirements of the application, rather than the technical details of how data is stored and accessed.
 
-## Benefit of using the repository pattern
-
-By using the repository pattern, we can easily swap out the underlying data storage mechanism without affecting the rest of the application. For example, we can switch from using a relational database to a NoSQL database, or even a completely different storage mechanism like a web API, with minimal changes to the rest of the application code. Additionally, the repository pattern can make it easier to test the application, as we can use mock repositories to simulate data storage for testing purposes. Here are some of the benefits of using the repository pattern:
-
--   Centralization of data access logic: all data access logic is contained within the repository, making it easier to maintain and change the data store implementation without impacting the rest of the application.
-
--   Abstraction of data store details: the repository provides an abstraction layer that hides the details of how data is stored and accessed, allowing the application to work with data in a more abstract and consistent way.
-
--   Separation of concerns: the repository separates business logic from data access logic, making the code easier to read, test, and maintain.
+-   **Separation of Concerns**: It decouples business logic from data access logic, enabling developers to focus on business rules without worrying about database operations.
+-   **Maintainability**: Centralizes data access logic within repositories, simplifying maintenance and updates to data storage implementations.
+-   **Abstraction**: Hides the complexities of the data layer from the rest of the application, providing a simplified and consistent interface for data operations.
+-   **Testability**: Makes testing easier by allowing the use of mock repositories or in-memory databases to simulate data persistence.
 
--   Improved testability: the repository can be easily mocked or stubbed in unit tests, allowing for more thorough testing of the business logic without needing to connect to a real data store.
+## Repository pattern implementation example
 
-Overall, the repository pattern is a powerful tool that can help developers build scalable and maintainable TypeScript applications that are more focused on business requirements and less on technical implementation details.
-
-## Example
-
-We offer an example of a Repository pattern implementation in the opinionated template of ExpressoTS.
-
-:::info
-In ExpressoTS, we implement the repository pattern in a specific folder called **"repositories"**, intentionally separated from the **"provider"** folder. We do this to emphasize the difference in repositories and providers, and how decoupling the two could benefit application development.
-:::
+In the following example, we will create a simple repository pattern implementation using TypeScript. We will define a base repository interface and class, as well as a concrete repository class for a `User` entity.
 
 ### Base repository interface
 
 ```typescript
-interface IEntity {
-    Id: string;
-}
-
 interface IBaseRepository<T> {
     create(item: T): T | null;
     update(item: T): T | null;
@@ -58,51 +39,28 @@ interface IBaseRepository<T> {
 
 ```typescript
 @provide(BaseRepository)
-class BaseRepository<T extends IEntity> implements IBaseRepository<T> {
-    private readonly DB: T[] = [];
-
-    create(item: T): T | null {
-        this.DB.push(item);
-        return item;
-    }
-
-    update(item: T) {
-        this.DB.push(item);
-        return item;
-    }
-
-    delete(id: string): boolean {
-        const index: number = this.DB.findIndex((item) => item.Id === id);
-
-        if (index != -1) {
-            this.DB.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-
-    find(id: string): T | null {
-        const user = this.DB.find((item) => item.Id === id);
-        return user || null;
-    }
-
-    findAll(): T[] {
-        return this.DB;
-    }
+class BaseRepository<T> implements IBaseRepository<T> {
+    // Implement the interface methods here
 }
 ```
 
-### User repository
+### Specific repository class
 
 ```typescript
 @provide(UserRepository)
-class UserRepository extends BaseRepository<User> {
-    constructor() {
-        super();
-    }
-}
+class UserRepository extends BaseRepository<User> {}
 ```
 
+The above example demonstrates the simplicity of creating a base repository that can be extended for specific entities like `User`.
+
+## Repositories vs providers
+
+While repositories focus on data interaction, providers in ExpressoTS typically offer functionalities such as environment validation or logging. Keeping repositories and providers distinct ensures clean separation and adheres to the single responsibility principle.
+
+:::info
+In ExpressoTS, repositories are housed within a dedicated "repositories" folder, distinguishing them from the "providers" folder. This structural choice emphasizes their distinct roles and facilitates a modular codebase.
+:::
+
 ---
 
 ## Support the project
diff --git a/tsconfig.json b/tsconfig.json
index 6f475698..54b338df 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,7 +1,8 @@
 {
-  // This file is not used in compilation. It is here just for a nice editor experience.
-  "extends": "@tsconfig/docusaurus/tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": "."
-  }
+    // This file is not used in compilation. It is here just for a nice editor experience.
+    "extends": "@tsconfig/docusaurus/tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": ".",
+        "module": "Node16"
+    }
 }