Learn why Gartner just named Builder a Cool Vendor

Announcing Visual Copilot - Figma to production in half the time

Builder.io logo
Contact Sales
Platform
Developers
Contact Sales

Blog

Home

Resources

Blog

Forum

Github

Login

Signup

×

Visual CMS

Drag-and-drop visual editor and headless CMS for any tech stack

Theme Studio for Shopify

Build and optimize your Shopify-hosted storefront, no coding required

Resources

Blog

Get StartedLogin

Great developers ensure that their web applications are optimized for peak performance. Users expect lightning-fast load times and smooth interactions, while search engines prioritize speedy sites in their rankings.

Web performance is key to engaging your customers for a a number of reasons:

  • Every second counts: Research shows that even small delays — even as small as milliseconds — in load time can lead to significant user drop-off and lost revenue.
  • User experience: A fast, responsive site provides a better user experience, leading to higher engagement and conversion rates.
  • SEO benefits: Search engines like Google factor in site speed when ranking pages, so a faster site can lead to better visibility. Server rendered content is easier to crawl which can boost your site’s SEO ranking.

The first step in optimizing your site is identifying where the problems lie. There are several tools you can use to analyze your website's performance. Some of the most popular are:

  • Google Lighthouse: Available in Chrome DevTools, Lighthouse provides performance scores and suggestions for improvement.
  • PageSpeed Insights: This tool analyzes your page and provides detailed metrics and recommendations.
  • WebPageTest: Compare Core Web Vitals, Lighthouse, or visual scores on different devices
  • Treo: Wraps Google’s CRUX raw data set in an easy-to-use user interface to show real core web vitals as opposed to point in time

These tools provide insights into key performance metrics like Largest Contentful Paint (LCP), First Input Delay (FID), and Cumulative Layout Shift (CLS), often referred to as Core Web Vitals.

For a deeper dive into Core Web Vitals visit SEO Aha Moment, understanding Core Web Vitals

It's important to understand that while Builder.io provides many performance-enhancing features, it is primarily a content delivery platform. The overall performance of your site will depend on how you use Builder.io in conjunction with other best practices.

What Builder doesWhat Builder can't do

✅ Deliver optimized content and images quickly

❌ Optimize your custom code or third-party scripts

✅ Integrate with SSR and SSG frameworks

❌ Fix performance issues in your overall site architecture

To get the most out of Builder's performance benefits:

For more information, visit Architecture Best Practices and Best Practices and Accessibility.

Builder is designed with performance in mind so that Builder can contribute to faster, more efficient websites.

  • Optimized content delivery: Builder.io uses a global CDN to ensure fast content delivery worldwide, reducing latency for users regardless of their location.
  • Automatic image optimization: When using the Builder Image API or Image block, images are automatically optimized and served in next-gen formats like WebP, significantly reducing page weight without sacrificing quality. You can also flag images as high fetch priority to prioritize above-the-fold images. For more detail, visit Builder's blog post Optimize Images in HTML.
  • Code splitting: Builder's SDKs support code splitting out-of-the-box, so that only necessary code is loaded for each Page or component. This reduces initial load times and improves overall performance.
  • Performance-conscious editing: The Builder interface encourages creating performant content by providing responsive previews and adhering to performance best practices.
  • Server-side rendering (SSR) and static site generation (SSG) support: Builder.io integrates seamlessly with frameworks that support SSR and SSG, so you can leverage these performance benefits while still using a visual editing UI.

While Builder provides a solid foundation for performance, there are additional steps you can take to further optimize your site.

The good news is that most tools that analyze site performance provide detailed analyses of your site’s performance and key problem areas. Most include links, detailed descriptions and plenty of resources to dig into the issues further. Some of the most common are:

JavaScript can be slow and expensive, especially as your app increases in complexity. And more often than not, it is the main culprit behind slow-loading websites. Here are some strategies to optimize your JavaScript:

  • Minimize and compress: Use tools like gzip to reduce the size of your JavaScript files. This can significantly cut down on load time.
  • Use code splitting: Don't send all your code at once. Instead, break it down into smaller chunks that load as needed. This technique ensures users only download the code they actually need.
  • Defer and lazy load: Prioritize above-the-fold content by deferring non-critical JavaScript. Use lazy loading to delay the loading of below-the-fold components until the user scrolls to them. You can use tools like Next Dynamic Import, React Loadable or the <Suspense/> paradigm.
  • Leverage web workers: For heavy tasks or third-party scripts, consider using web workers with a tool like Partytown. Web workers move the workload off the main thread, improving page responsiveness and overall performance.
  • Remove unused code: Audit your codebase regularly and remove any unused JavaScript to reduce overall file size.

Images often make up a large portion of a Page's weight. Here's how to optimize them:

  • Use responsive images: Use the srcset attribute to serve different image sizes based on the user's device. This way users aren't loading unnecessarily large images on smaller screens.
  • Adopt next-gen formats: Serve images in WebP format using the <picture> tag. This format offers better compression and quality. Remember to provide fallbacks for older browsers.
  • Implement lazy loading: Use attributes like loading="lazy" and fetchpriority="low" for non-critical images. This conserves bandwidth and improves initial load times.
  • Automate optimization: Builder automatically optimizes images, handling compression and delivery in next-gen formats. This takes a significant burden off developers and ensures consistent Page optimization across your site.
  • Avoid gifs and be selective about videos: They can grab attention and can be very effective in the right context, but should be used sparingly, especially in the case of embedded videos.

For more information, visit Working with Images and Working with Videos.

CSS can also impact your site's performance. Here are some tips:

  • Inline critical CSS: Place critical CSS directly in the HTML to ensure immediate rendering of above-the-fold content. Defer non-critical styles for later loading.
  • Minify and concatenate: Reduce file size by minifying CSS files and combining them into a single file. This reduces the number of HTTP requests, speeding up Page load time.
  • Avoid @import: Instead of using @import, use multiple <link> tags to load CSS files in parallel to reduce render-blocking time.

Third-party scripts can significantly slow down your site. Here's how to manage them:

  • Use web workers: Using tools like Partytown to move third-party scripts to web workers can help free up the main thread for rendering critical resources.
  • Load strategically: Ensure critical elements load before third-party scripts. Use frameworks like Next.js that offer script strategies to defer and async load non-essential scripts.

One of the biggest performance gains you can achieve is by implementing server-side rendering (SSR) or static site generation (SSG):

  • Pre-rendered content: SSR and SSG pre-render content on the server, reducing the load on the client's device and improving initial load times.
  • Consistent performance: By rendering on the server, you ensure a more consistent experience across different devices and network conditions.
  • SEO benefits: Pre-rendered content is typically more SEO-friendly, as search engines can easily crawl and index the content.

Builder.io integrates seamlessly with frameworks that support SSR and SSG, allowing you to leverage these performance benefits while still using a visual editing interface.

Hydration errors can negatively impact your page performance by forcing a fallback to client-only rendering, which can lead to content shifts or broken layouts.

It’s crucial to identify and fix any hydration errors before deploying your site to production. Builder offers a tool to assist with this, covered in the blog post Announcing React Hydration Overlay - Easily Squash Hydration Errors, but the root cause is often in the application’s code.

Consistently monitor and measure your site's performance to identify areas for improvement:

  • Use automated tools: Regularly audit your site with tools like Google Lighthouse, PageSpeed Insights, or WebPageTest to identify and address performance bottlenecks.
  • Focus on Core Web Vitals: Pay special attention to metrics like Largest Contentful Paint (LCP), First Input Delay (FID), and Cumulative Layout Shift (CLS). These directly affect user experience and SEO rankings.
  • Continuous optimization: Web performance isn't a one-time task. Regularly review your site's performance and make incremental improvements.

Builder is a powerful tool for serving content quickly and efficiently across all of your applications. While it may not necessarily improve your performance scores, it shouldn’t negatively impact them either. As a content delivery platform, Builder strives to follow best practices, but ultimately, your content and architectural decisions play a critical role in your site’s performance.

By implementing these best practices, you can significantly enhance your web app's performance, resulting in better user experiences, higher conversion rates, and improved SEO rankings.

Like all aspects of web development, performance optimization is an ongoing process. Stay informed about the latest trends and tools, and regularly audit your site’s performance to ensure you’re providing the best possible experience for your users.

By leveraging Builder performance-focused features and following these best practices, you can create engaging websites without sacrificing speed and efficiency.

Was this article helpful?

Product

Visual CMS

Theme Studio for Shopify

Sign up

Login

Featured Integrations

React

Angular

Next.js

Gatsby

Get In Touch

Chat With Us

Twitter

Linkedin

Careers

© 2020 Builder.io, Inc.

Security

Privacy Policy

Terms of Service

Newsletter

Get the latest from Builder.io

By submitting, you agree to our Privacy Policy

Product

Platform Overview

Integrations

What's New

Open Source

Builder

Builder

Mitosis

Mitosis

Mitosis

AI Shell

Mitosis

Micro Agent

Mitosis

GPT Crawler

Qwik

Qwik

Partytown

Partytown

Popular Guides

From Design to Code Guide

Composable Commerce Guide

Headless CMS Guide

Headless Commerce Guide

Composable DXP Guide

Design to Code

Resources

Blog

Knowledge Base

Community Forum

Partners

Templates

Success Stories

Showcase

Resource Center

Frameworks

React

React

Next

Next.js

Qwik

Qwik

Gatsby

Gatsby

Angular

Angular

Vue

Vue

Svelte

Svelte

Remix logo

Remix

Nuxt

Nuxt

Hydrogen

Hydrogen

See All

© 2024 Builder.io, Inc.

Security

Privacy Policy

SaaS Terms

Security & Compliance

Cookie Preferences

Gartner Cool Vendor 2024