Strategies for Crafting High-Performance Web Apps with Smaller Bundle Sizes
Published: 2024-01-15 21:42:11

In Benjamin Franklin's essay “Advice to a Young Tradesman”, he said, “Remember that time is money”. [Digital.com](http://Digital.com)'s 2022 website speed statistics [found that](https://digital.com/website-speed-statistics/#:~:text=Half%20of%20customers%20will%20abandon%20their%20shopping%20carts%20if%20pages%20don%E2%80%99t%20load%20fast%20enough) — Half of customers will abandon their shopping carts if pages don’t load fast enough. This startling statistic underscores the critical importance of web performance in today's online experience.

Web performance has evolved from a technical nice-to-have into a fundamental component of user experience and business success. It's not just about speed; it's about how quickly and smoothly users can interact with content. Google's emphasis on user experience metrics, particularly with the introduction of Core Web Vitals in 2019, has shifted the focus from mere presence to performance excellence. After going through 100 million page views, [Portent](https://www.notion.so/43e9604c9f3c4e1eb986a71a3855fe65?pvs=21) says that a site that loads in 1 second has a conversion rate 3x higher than a site that loads in 5 seconds.

In this high-stakes environment, one critical aspect often overlooked is the size of web bundles. As web applications grow more complex, the need to manage and optimize bundle size becomes paramount. The journey towards a leaner, faster web experience is not just about adopting new technologies but also about rethinking our approach to building and delivering web content.

In the following sections, we'll delve deeper into what bundle size means, its direct impact on web performance, and strategies for efficient bundling, with a focus on AWS Amplify's approach to optimizing bundle size for better performance.

## Understanding Bundle Size and Its Impact

Bundle size refers to the total size of the files delivered to users when they visit a web page. This includes HTML, CSS, JavaScript, images, and other media. In the web development process, these resources are often "bundled" together to streamline deployment and load times. However, larger bundles can significantly slow down website performance because they take longer to download and process, especially on mobile devices or slower internet connections. 

Larger bundles can significantly slow down website performance primarily due to increased load times. When a user visits a website, their browser needs to download and process all the bundled resources like JavaScript, CSS, and images. Larger bundles have more data, so they take longer to download, especially on slower internet connections or mobile devices. This delay in loading can lead to a sluggish user experience. Additionally, the browser must also parse and execute JavaScript, which can be time-consuming for larger bundles, further impacting the site's responsiveness and interactivity.

Users tend to have a low tolerance for slow-loading websites, often abandoning them if they don't load quickly enough. This behavior impacts metrics such as bounce rates, page views, and, ultimately, conversions and sales. Additionally, search engines like Google consider page load speed as a ranking factor, so slower websites might rank lower in search results, leading to reduced visibility.

Given these implications, developers need to focus on optimizing bundle size. This involves strategies like minifying files, using compression algorithms, and implementing techniques like lazy loading, which only loads parts of a web page when needed. By reducing bundle size, websites can load faster, providing a better user experience and potentially improving SEO rankings.

In the upcoming sections, we'll explore various strategies for optimizing bundle size and how AWS Amplify implements these strategies to improve web application performance.

## Strategies for Efficient Bundling

In optimizing web bundle sizes, a combination of technical strategies and tools is essential.

### Modular Code and Tree Shaking

Breaking down code into smaller, reusable modules is crucial. It allows for 'tree shaking', a process where unused code is eliminated. Think of your application as a tree with various branches (modules). Each branch has leaves (functions, variables, classes). In a large tree, not all leaves are necessary for the health of the tree. Tree shaking is the process of shaking the tree (your application) to drop unnecessary leaves (unused code) to keep it healthy and efficient.

Consider a JavaScript module that exports several functions. In a typical scenario, a web application might only use a subset of these exported functions. Traditional bundling processes include the entire set of exports, even the unused ones. Tree shaking effectively identifies and removes these unused exports, reducing the final bundle size.

```jsx
// Initial Module
export function usedFunction() { ... }
export function unusedFunction() { ... }

// In your application
import { usedFunction } from './module';

// After tree shaking, 'unusedFunction' is not included in the bundle.
```

The primary benefit of tree shaking is the reduction in the size of the final JavaScript bundle sent to the browser. Smaller bundles mean faster load times, improved performance, and enhanced user experience, especially crucial for users on mobile devices or slow internet connections.

### Lazy Loading with Dynamic Imports

Lazy loading is a technique that enhances web performance by loading resources only when they are needed. This is particularly useful for large-scale applications where loading everything upfront can lead to significant delays. By deferring the loading of non-critical resources, such as images, scripts, or even entire modules, until the point of use, lazy loading can improve initial load times and reduce the strain on network resources.

Dynamic imports in JavaScript allow developers to implement lazy loading efficiently. The **`import()`** function can be used to load a module dynamically, and this operation returns a promise. The module is only fetched when the **`import()`** function is called, which is typically triggered by a user action or other specific conditions.

```jsx
// Using dynamic import() for lazy loading a module
import('path/to/module').then((module) => {
  // Module is now loaded and can be used
  module.someFunction();
});
```

Lazy loading with dynamic imports significantly improves user experience, particularly for users with slower internet connections or limited bandwidth. It ensures that users are not overwhelmed with long wait times by loading only what's necessary when it's necessary.

### Analyzing Bundles with Webpack Bundle Analyzer

[Webpack Bundle Analyzer](https://www.npmjs.com/package/webpack-bundle-analyzer) is a powerful tool for visualizing the size of webpack output files. It provides an interactive treemap visualization that makes it easier to understand the size of different parts of a bundled application. By using this tool, developers can identify which parts of their code are contributing the most to the bundle size. This insight is crucial for pinpointing large chunks of code or unnecessary dependencies that could be optimized or removed to reduce the overall size of the application.

![](https://paper-attachments.dropboxusercontent.com/s_665EC01FBBF66F6C5CE00451ECAE751751DEF473ADB6D8C5E3CA84E5F64E7B0D_1705350055059_CleanShot_2024-01-09_at_20.31.312x.png)

This tool is particularly useful in complex projects where it's challenging to manually track down sources of bloat in the code.

### Code Splitting

Code splitting is a technique where the main bundle of an application is split into smaller chunks that are loaded as needed, rather than all at once. This strategy is particularly beneficial for large applications, where the volume of code can cause significant load times if it were all to be loaded upfront.

Code splitting could be considered at multiple granularities. At its simplest, it might mean separating application code from third-party library code. More sophisticated approaches involve splitting code at the component or route level, ensuring that users download only the code necessary for what they are currently engaging with. In React, for instance, this involves using **`React.lazy`** for component-level code splitting, alongside **`Suspense`** for handling the loading interface, which would be something like this:

```jsx
import { Suspense, lazy } from 'react';
const LazyComponent = lazy(() => import('./LazyComponent'));

function MyComponent() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <LazyComponent />
    </Suspense>
  );
}
```

Frameworks like [Next.js](https://nextjs.org/) take this a step further, automating route-based code splitting so that developers don't have to manually define split points. The framework takes care of loading the JavaScript necessary for rendering the page when a new route is visited.

For a complex application, the implementation of code splitting can lead to significantly improved load times, reducing the amount of code processed and rendered during the initial load. This not only shortens the time to interactive but also conservatively uses bandwidth, an important consideration for users on limited or metered connections.

## AWS Amplify's Approach to Bundle Size Reduction

[AWS Amplify](https://aws.amazon.com/amplify/?gclid=EAIaIQobChMIgqGn56zggwMVqJZQBh2vkQuOEAAYASAAEgIsUfD_BwE&trk=bde46bbc-b618-48e1-b86a-1dd4c35b930f&sc_channel=ps&ef_id=EAIaIQobChMIgqGn56zggwMVqJZQBh2vkQuOEAAYASAAEgIsUfD_BwE:G:s&s_kwcid=AL!4422!3!647301968149!e!!g!!aws%20amplify!19621293721!146139123512) is widely used for building full-stack web applications, offering a range of functionalities, including authentication, storage, and internationalization. However, a significant concern among developers has been the large bundle size of the [Amplify library](https://docs.amplify.aws/javascript/prev/build-a-backend/), as highlighted in community discussions, such as a [GitHub issue raised in April 2022](https://github.com/aws-amplify/amplify-js/issues/9817#issue-1206596019). The issue emphasized that the library, especially for services like [Auth](https://docs.amplify.aws/javascript/build-a-backend/auth/set-up-auth/) and [S3](https://aws.amazon.com/pm/serv-s3/?gclid=EAIaIQobChMI9J3IqK3ggwMVCKqDBx1vJgudEAAYAiAAEgKnhfD_BwE&trk=777b3ec4-de01-41fb-aa63-cde3d034a89e&sc_channel=ps&ef_id=EAIaIQobChMI9J3IqK3ggwMVCKqDBx1vJgudEAAYAiAAEgKnhfD_BwE:G:s&s_kwcid=AL!4422!3!638364429349!e!!g!!s3%20storage!19096959014!142655567223) storage, contributed heavily to the overall bundle size of projects.

Responding to these concerns, the AWS Amplify team embarked on a technical mission to optimize the library. They focused on refining their approach to dependencies and leveraging more native browser APIs like [Fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API), significantly reducing the reliance on heavier external libraries like [Axios(https://axios-http.com/docs/intro). This strategic shift led to a substantial reduction in the bundle size – by 42% for Auth, 41% for Notifications and Analytics, and 45% for Storage.

![](https://paper-attachments.dropboxusercontent.com/s_665EC01FBBF66F6C5CE00451ECAE751751DEF473ADB6D8C5E3CA84E5F64E7B0D_1705350073539_Untitled.png)

The introduction of functional APIs in Amplify v6 has contributed to more efficient bundling. With these APIs, only the imported functionalities impact the bundle size. For instance, in an app using a subset of APIs from Auth and Storage, there was a reported 59% reduction in bundle size from version 5 to version 6.

These improvements demonstrate Amplify's commitment to addressing performance concerns and enhancing user experience by optimizing its library's efficiency. The changes not only benefit current users but also make Amplify a more attractive option for developers prioritizing performance in their projects.

### Amplify Your Web Performance

Today, web performance is a critical factor, not just an afterthought. Developers need to be vigilant about the bundle size of external services or dependencies, as these can significantly impact application performance.

AWS Amplify, with its recent strides in optimizing bundle size, emerges as a strong contender for full-stack web projects. By choosing Amplify, developers can leverage the benefits of an optimized, efficient library, ensuring better performance and a smoother user experience in their applications. This choice aligns with a performance-focused development approach, where efficient bundles play a key role in the success of web projects.

## Conclusion

The future of bundle size reduction in web performance is increasingly focused on advanced tools like SWC and smarter coding practices. SWC, a Rust-based tool, is gaining popularity for its high-speed capabilities in JavaScript and TypeScript processing. Its efficiency in compilation, bundling, minification, and transformation can lead to significantly leaner applications. 

Simultaneously, the web development community is emphasizing smarter coding practices. This involves leveraging native web platform capabilities and minimizing reliance on heavy frameworks. By starting with HTML and CSS and using JavaScript only when necessary, developers can significantly reduce their dependency on large libraries, leading to lighter bundle sizes. Such practices not only enhance performance but also align with modern web standards, promoting more efficient and sustainable development approaches.

In this article, we've delved into various strategies such as modular code and tree shaking, lazy loading, bundle analysis, and code splitting, each contributing to more efficient, faster-loading web applications. The case study of AWS Amplify underscores the importance of this approach, showcasing how a significant reduction in bundle size can lead to better performance and enhanced user experiences.