CLI Builders in Angular: Enhancing the Build Process

Anton Ioffe - December 10th 2023 - 10 minutes read

In the dynamic landscape of modern web development, Angular remains a premier platform, providing developers with powerful tools to sculpt and refine their applications. However, the true artisanship lies in mastering the subtleties of its build process—this is where Angular CLI builders enter the stage. Through the course of this article, we'll embark on a comprehensive journey to unlock the full potential of CLI builders, dissect the creation of a custom builder, deploy performance enhancements that shatter limitations, and navigate the intricacies of best practices to avoid common pitfalls. We delve into the rigor of testing and debugging to forge builders that are not only robust but also impeccably reliable. Prepare to elevate your Angular build process to a symphony of efficiency and finesse, an endeavor that promises to enrich your development toolkit and transform the way you perceive the compilation of your ambitious Angular projects.

Unleashing the Power of Angular CLI Builders

Angular CLI builders provide a potent mechanism for extending the capabilities of the Angular CLI, enabling developers to tailor the build process to their specific needs and workflows. At their core, CLI builders are functions with the power to access and manipulate the build context, thereby representing a significant opportunity for optimization and customization.

A common issue addressed by CLI builders is the slow build process. By leveraging the extensibility of CLI builders, teams can implement incremental builds or integrate alternative build tools that offer faster compilation times. For example, Angular 17 introduced an esbuild builder, which substantially reduced build times by leveraging the fast JavaScript bundler and minifier. This capacity to swap out or modify the underlying tools is a testament to the versatility of CLI builders.

The flexibility of CLI builders doesn't end with performance tweaks, though. They serve as an extension point for introducing custom functionality into the development workflow. From checking for specific project configurations, such as ensuring a package.json script adheres to team standards, to adding commands for bespoke task automation, CLI builders can significantly enhance the developer experience. The ability to prompt the user and modify the project dynamically in response to input makes this feature remarkably powerful.

Moreover, CLI builders play a crucial role in assisting with modern Angular applications that require a high degree of customization. As projects grow in complexity, standard build configurations may no longer suffice. CLI builders provide the customizability needed to manage this complexity, ensuring that the Angular CLI can adapt to a wide array of project requirements, thereby aiding modularity, maintainability, and scalability.

Embracing CLI builders is a forward-thinking move, reflective of Angular's dedication to evolving with web development needs. It's important to note that Angular CLI's adoption of Bazel (under the @angular/bazel package) for commands like ng build, ng serve, and ng test showcased early signs of this extensibility. Now, with seamless integration of faster build tools and developers' ability to create custom builders, Angular continues to innovate, ultimately offering an environment that is both high-performing and tailored to the unique demands of enterprise-scale applications.

Anatomy of a Custom CLI Builder

To craft a custom Angular CLI builder, begin by setting up a foundational framework within your project. Initiate a new package using npm init and install necessary dependencies, such as the Angular DevKit. Your project structure should include a builders.json file which registers the builders available in the package, and a TypeScript source file where the builder's functionality will be defined. This initial setup paves the way for efficient development, ensuring that all builders are properly referenced and can be conveniently distributed as a part of an npm package.

The core of a CLI builder is its main logic, a function that typically receives a context object containing metadata such as the project tree and logger. A typical pattern is to define an asynchronous function that returns a BuilderOutput observable. This function orchestrates the heavy lifting that your custom logic must perform. For instance, to enforce consistency in the package.json scripts, the builder could check for the presence and accuracy of the build script, offering a remediation if the validation fails. Leveraging the context, it can output messages or set the success status, thereby enriching the development experience with real-time feedback.

Error handling is a crucial facet of the builder's infrastructure. The goal is to make the error messages as helpful as possible to mitigate any negative impact on the developer's workflow. Wrap potentially problematic code segments with try-catch blocks and make liberal use of the context's logger API to inform the user of what went wrong and possibly suggest resolutions. This empathy toward the user's experience translates to faster debugging and recovery from issues.

To amplify its usefulness, the builder must provide an API that's flexible and consumable by the end-user. This is achieved through defining a schema for the builder's options which is outlined in a separate JSON file. It details the API, specifying what options are available, their types, default values, and descriptions. Users can then utilize these options in the angular.json file, configuring the builder according to their specific project needs and adding a layer of customization to the development process.

Wrapping up the creation of a custom builder involves wiring it up to the Angular CLI. Update the angular.json file by introducing a new architect entry that references your custom builder using its designated name, then register the builder with a unique identifier. Now, developers can invoke it directly via the Angular CLI using ng run commands. This seamless integration streamlines project tasks and enhances the overall project structure, allowing teams to work smarter with tools tailored to their unique workflows.

Performance Tuning: Strategies and Techniques

Differential loading is a technique adopted by the Angular CLI to serve different sets of bundles to modern and legacy browsers. This approach leverages the fact that modern browsers support ES6+ syntax, which allows serving lighter and more efficient bundles to them. Older browsers receive transpiled ES5-compliant bundles, ensuring compatibility at the cost of additional overhead. While differential loading boosts performance for users on modern browsers through smaller bundle sizes, it introduces complexity in managing multiple builds and potentially increases build times for the developer.

Lazy loading is another performance-enhancing strategy where modules are loaded on demand rather than at the initial load. Angular supports lazy loading of feature modules via the Angular router, significantly reducing the initial bundle size. This approach improves the startup performance, especially in applications with large codebases or many features. However, the segregation of modules into lazy-loaded features requires careful planning to avoid impacting the user experience negatively, as poorly planned chunking can lead to frequent loading screens or delays when navigating the application.

Tree-shaking, a term popularized by build tools like webpack, is a process that eliminates unused code from the final bundle. In an Angular context, this means that any services, components, or other Angular entities that are not used will not be included in the production build. Through the use of ES6 module syntax, tree-shaking is most effective since it relies on the static structure of module imports and exports. However, its effectiveness can be diminished if the application includes libraries or patterns that prevent tree-shaking from correctly identifying unused code.

Advanced webpack configurations can also be exploited to enhance build performance. Customizing webpack's module resolution, utilizing caching, and applying more aggressive splitting strategies can lead to faster rebuilds and smaller bundles. Nevertheless, delving into complex webpack configurations requires a deep understanding of how modules are bundled and processed. This might overcomplicate the build process and introduce barriers for less experienced developers. Moreover, maintaining a custom webpack configuration might become burdensome as dependencies and tools evolve.

In striving to optimize an application's build performance, it is crucial to strike a balance between the level of complexity introduced and the performance gain achieved. For example, enabling Ahead-of-Time compilation provides performance benefits by compiling templates at build time, reducing the client-side workload. Conversely, this can slow down build times and might necessitate additional configurations. Ultimately, each strategy should be carefully assessed considering the specific needs of the application and its users, prioritizing techniques that offer the best trade-offs in terms of build performance and simplicity.

Pitfalls and Best Practices in CLI Builder Implementation

One common pitfall when implementing Angular CLI builders is overlooking error handling. Failing to catch and log errors can lead to opaque build failures where developers waste time deciphering cryptic messages. A best practice is to apply comprehensive try-catch blocks around the logic of your builders. Properly utilize the context's logger API to emit meaningful error messages that guide the developer to the root cause and the potential solution. Incorrect handling might look like a silent failure upon encountering an error, while the recommended approach is:

import { BuilderContext, BuilderOutput } from '@angular-devkit/architect';

export default async function myBuilder(options: any, context: BuilderContext): Promise<BuilderOutput> {
    try {
        // Builder logic goes here
        return { success: true };
    } catch (error) {
        context.logger.error('Failure: ', error.message);
        return { success: false };

Memory leaks are another overlooked aspect, often stemming from inefficient use of observables or event emitters. The improper management of subscriptions could lead to builders holding on to memory unnecessarily. Developers must ensure that they unsubscribe from all observables and clean up event listeners. The wrong approach would ignore the teardown logic, whereas the following exemplifies proper memory management:

import { Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';

const terminate$ = new Subject(); // Used for signaling teardown

function subscribeWithCleanup(source$: Observable<any>) {
    source$.pipe(takeUntil(terminate$)).subscribe(value => {
        // Use the value

// Later in your code, when you know the builder's work is done

Reusability and modularity issues arise when builders are developed with a narrow focus, disregarding potential use in other contexts. Always design builders to be as generic as possible, allowing them to be leveraged across different projects or parts of the same project. A poorly implemented builder might hardcode project-specific logic, while a modular one provides flexibility:

function buildPipeline(options, context) {
    if(options.projectSpecific) {
        // Project-specific actions
    // Generic actions that any project can use

Complexity can unnecessarily escalate if builders are not conceived with simplicity in mind. Overengineering solutions for marginal gains leads to maintainability challenges and steep learning curves for new team members. Counteract this by ensuring each builder has a single responsibility and is easy to comprehend. Avoiding overly nested structures and extensive configuration options where simpler solutions can suffice is fundamental. Here’s an unnecessarily complex builder versus a streamlined, single-focused one:

// Unnecessarily complex and unfocused builder
function complexBuilder(options, context) {
    // Confusing and intermingled logic that is hard to follow and maintain

// Streamlined, single-purpose builder
function simpleBuilder(options, context) {
    // Direct, to-the-point logic that’s easily maintainable

Lastly, developers often neglect the extensibility and testability of their builders. Ensure that your builders can be extended for further customization without modifying the original codebase. Also, write unit tests for builders as you would for any other piece of code to safeguard against future regressions. It is a mistake to treat builders as final, unchangeable scripts; instead, approach them as living code that benefits from solid testing and extendability practices:

// Builder function that’s hard to test and extend
function myOpaqueBuilder(options, context) {
    // Complex logic that’s tightly coupled and not easily mockable

// Builder function designed for extensibility and testability
function myTestableBuilder(options, context) {
    // Loosely coupled logic that allows for mocking and extension

Testing and Debugging Your CLI Builders

Testing and debugging custom CLI builders is a crucial step to ensure they function correctly and are maintainable over time. The ideal approach involves setting up both unit and integration tests. Unit tests help verify each part of the builder’s code in isolation, mocking dependencies as necessary. Integration tests, on the other hand, ensure that the builder interacts as intended with the Angular CLI and the broader application context. For thorough test coverage, it's important to simulate various scenarios and edge cases that the builder might encounter, thus safeguarding against future changes that may otherwise break its functionality.

When setting up tests, leveraging the Angular DevKit architecture can streamline the process. Developers should create a suite of test cases using the ArchitectTestBed to load builders and run them within a controlled environment that mimics the real Angular CLI context. This allows repeatable testing of how the builder reacts to different configuration settings and project structures. To avoid brittle tests, refrain from relying on external services or the file system; instead, use the virtual file system provided by the DevKit’s HostTree for a more reliable and faster test execution.

For enabling debugging, developers can use the Node.js inspect flag to step through their builder code. It’s beneficial to add breakpoints or console.log statements within the builder logic to examine the state at various execution points. While console.log can often be sufficient for quick checks, leveraging the structured logging provided by the context.logger API enriches the debugging information, offering insights into the internal execution flow of the builder without cluttering terminal output. It's good practice to provide detailed log messages to assist in diagnosing problems when they arise.

A sound versioning strategy is vital for maintaining builders as they evolve. Semantic versioning can communicate the nature of changes to consumers, while maintaining a changelog provides a clear history of modifications and improvements. Continuous integration pipelines can aid in this process, automatically running the test suite against different versions of dependencies and the Angular CLI itself, to quickly identify potential incompatibilities. Automated tools should be used to enforce coding standards and automatically run tests before merging code changes, ensuring that only well-tested code makes it to the production.

Lastly, documentation within the codebase should be a priority. It helps new contributors understand the intended behavior and existing structure of builders, reduces the learning curve, and guides future development. As the builder evolves, keeping documentation up to date is as important as the code changes themselves. Comments explaining the rationale behind complex logic can save hours of debugging for future maintainers. Following these strategies ensures that your CLI builders remain reliable, performant, and easy to maintain as your Angular application scales over time.


In this article, we explore the power of CLI builders in Angular and how they can enhance the build process of web applications. We dive into the benefits of CLI builders, such as performance improvements, customization, and modularization. Additionally, we provide insights into the implementation of a custom CLI builder and offer tips for performance tuning, pitfalls to avoid, and best practices. The article concludes with advice on testing, debugging, and documentation. As a challenge for the reader, we encourage them to create their own CLI builder that addresses a specific need in their Angular project, showcasing their skills in optimizing the build process and improving developer experience.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers