Web site Developer I Advertising I Social Media Advertising I Content material Creators I Branding Creators I Administration I System SolutionOptimizing Measurement And Efficiency (Half 3) — Smashing Journal

Web site Developer I Advertising I Social Media Advertising I Content material Creators I Branding Creators I Administration I System SolutionOptimizing Measurement And Efficiency (Half 3) — Smashing Journal

Web site Developer I Advertising I Social Media Advertising I Content material Creators I Branding Creators I Administration I System Resolution

Fast abstract ↬

Refactored codebase ought to lead to related or improved efficiency and improved codebase well being. In spite of everything, if deploying the refactored codebase causes loading or efficiency points, it’ll lead to much less site visitors and income. Fortunately, there are lots of optimization strategies we will apply to sort out potential file dimension and efficiency points.

In earlier articles from this sequence, we’ve coated auditing CSS codebase well being and the incremental CSS refactoring technique, testing, and upkeep. No matter how a lot the CSS codebase has been improved in the course of the refactoring course of and the way way more maintainable and extendable it’s, the last stylesheet must be optimized for the very best efficiency and least attainable file dimension.

Deploying the refactored codebase shouldn’t lead to worse web site efficiency and worse consumer expertise. In spite of everything, customers received’t wait round perpetually for the web site to load. Additionally, the administration can be dissatisfied with the decreased site visitors and income attributable to the unoptimized codebase, regardless of the code high quality enhancements.

On this article, we’re going to cowl CSS optimization methods that may optimize CSS file dimension, loading instances, and render efficiency. That manner, the refactored CSS codebase is just not solely extra maintainable and extensible but in addition performant and checks all packing containers which are vital each to the end-user and administration.

Optimizing Stylesheet File Measurement

Optimizing file dimension boils all the way down to eradicating pointless characters and formatting and optimizing the CSS code to make use of completely different syntax or shorthand properties to scale back the general variety of characters in a file.

Optimization And Minification

CSS optimization and minification have been round for years and have become a staple in frontend optimization. Instruments like cssnano and clean-css are amongst my favourite instruments in relation to CSS optimization and minification. They provide all kinds of customization choices to additional management how code is being optimized and which browsers are supported.

These instruments work in an analogous manner. First, the unoptimized code is parsed and transpiled following the principles set within the config. The result’s the code that makes use of fewer characters however nonetheless retains the formatting (line breaks and whitespaces).

/* Earlier than - unique and unoptimized code */
.container {
  padding: 24px 16px 24px 16px;
  background: #222222;

/* After - optimized code with formatting */
.container {
  padding: 24px 16px;
  background: #222;

And at last, the transpiled optimized code is minified by eradicating all pointless textual content formatting. Relying on the codebase and supported browsers set within the config, code with deprecated vendor prefixes can even get eliminated.

/* Earlier than - optimized code with formatting */
.container {
  padding: 24px 16px;
  background: #222;

/* After - optimized and minified code */
.container{padding:24px 16px;background:#222}

Even on this fundamental instance, we’ve managed to scale back the general file dimension from 76 bytes to 55 bytes, leading to a 23% discount. Relying on the codebase and the optimization instruments and config, CSS optimization and minification might be much more efficient.

CSS optimization and minification might be thought of as a simple win because of the vital payoff with just some tweaks to the CSS workflow. That’s the reason minification must be handled because the naked minimal efficiency optimization and a requirement for all stylesheets on the venture.

Extra after leap! Proceed studying under ↓

Optimizing Media Queries

Once we write media queries in CSS, particularly when utilizing a number of information (PostCSS or Sass), we normally don’t nest the code beneath a single media question for a whole venture. For improved maintainability, modularity, and code construction, we normally write the identical media question expressions for a number of CSS parts.

Let’s think about the next instance of an unoptimized CSS codebase.

.web page {
  show: grid;
  grid-gap: 16px;

@media (min-width: 768px) {
  .web page {
    grid-template-columns: 268px auto;
    grid-gap: 24px;

/* ... */

.products-grid {
  show: grid;
  grid-template-columns: repeat(2, 1fr);
  grid-gap: 16px;

@media (min-width: 768px) {
  .products-grid {
    grid-template-columns: repeat(3, 1fr);
    grid-gap: 20px;

As you’ll be able to see, we’ve got a repeated @media (min-width: 768px) per element for higher readability and upkeep. Let’s run the optimization and minification on this code instance and see what we get.

.web page{show:grid;grid-gap:16px}@media (min-width: 768px){.web page{grid-template-columns:268px auto;grid-gap:24px}}.products-grid{show:grid;grid-template-columns:repeat(2,1fr);grid-gap:16px}@media (min-width: 768px){.products-grid{grid-template-columns:repeat(3,1fr);grid-gap:20px}}

This may be a bit tough to learn, however all we’ve got to note is the repeated @media (min-width: 768px) media question. We’ve already concluded that we wish to scale back the variety of characters in a stylesheet and we will nest a number of selectors beneath a single media question, so why didn’t the minifier eliminated the duplicated expression? There’s a easy cause for that.

Rule order issues in CSS, so to merge the duplicated media queries, code blocks should be moved. This can lead to rule orders being modified which might trigger undesirable side-effects in kinds.

Nonetheless, combining media queries might probably make the file dimension even smaller, relying on the codebase and construction. Instruments and packages like postcss-sort-media-queries permit us to take away duplicated media queries and additional scale back the file dimension.

After all, there may be the vital caveat of getting a well-structured CSS codebase construction that doesn’t rely upon the rule order. This optimization must be taken into consideration when planning the CSS refactor and establishing floor guidelines.

I’d suggest first checking if the optimization profit outweighs the potential dangers. This may be simply accomplished by operating a CSS audit and checking media question stats. If it does, I’d suggest including it afterward and operating automated regression testing to catch any sudden side-effects and bugs that may occur because of this.

Eradicating Unused CSS

Throughout the refactoring course of, there may be all the time a chance that you simply’ll find yourself with some unused legacy kinds that haven’t been utterly eliminated otherwise you’ll have some newly added kinds that aren’t getting used. These kinds additionally add to the general character depend and the file dimension. Eliminating these unused kinds utilizing automated instruments, nevertheless, might be considerably dangerous as a result of the instruments can’t precisely predict which kinds are literally used.

Instruments like purgecss undergo all of the information within the venture and use all of the lessons talked about in information as selectors, simply to err on the facet of warning and never unintentionally delete selectors for dynamic, JavaScript-injected parts, amongst different potential instances. Nonetheless, purgecss provides versatile config choices as workarounds for these potential points and dangers.

Nonetheless, this enchancment must be accomplished solely when the potential advantages outweigh the dangers. Moreover, this optimization approach would require appreciable time to arrange, configure and take a look at, and may trigger unintended points down the road, so proceed with warning and guarantee that the setup is bulletproof.

Eliminating Render-Blocking CSS

By default, CSS is a render-blocking useful resource, which means that the web site received’t be displayed to the consumer till all linked stylesheets and their dependencies (fonts, for instance) have been downloaded and parsed by the browser.

Example of render-blocking CSS with font stylesheet and font file dependency

Instance of render-blocking CSS with font stylesheet and font file dependency. (From net.dev beneath Inventive Commons Attribution 4.0 License) (Giant preview)

If the stylesheet file has a big file dimension or a number of dependencies that are positioned on third-party servers or CDNs, web site rendering might be delayed considerably relying on the community velocity and reliability.

Largest Contentful Paint (LCP) has change into an vital metric in the previous few months. LCP is just not solely vital for efficiency but in addition website positioning — web sites with higher LCP scores can have higher search outcomes rating. Eradicating render-blocking assets like CSS is a technique of enhancing the LCP rating.

Nonetheless, if we might defer the stylesheet loading and processing, this may lead to Flash Of Unstyled Content material (FOUC) — content material could be exhibited to the consumer straight away and kinds could be loaded and utilized a number of moments later. This change might look jarring and it might even confuse some customers.

Crucial CSS

With Crucial CSS, we will be sure that the web site hundreds with the minimal quantity of kinds that are assured for use on the web page when it’s initially rendered. This manner, we will make the FOUC a lot much less noticeable and even eradicate it for many instances. For instance, if the homepage incorporates a header element with navigation and a hero element positioned above-the-fold, which means that the vital CSS will include all the mandatory international and element kinds for these parts, whereas kinds for different parts on the web page can be deferred.

This CSS is inlined in HTML beneath a type tag, so the kinds are loaded and parsed alongside the HTML file. Though this can lead to a barely bigger HTML file dimension (which must also be minified), all different non-critical CSS can be deferred and received’t be loaded straight away and the web site will render sooner. All in all, the advantages outweigh the rise within the HTML file dimension.

  <type kind="textual content/css"><!-- Minified Crucial CSS markup --></type>

There are numerous automated instruments and NPM packages on the market, relying in your setup, that may extract vital CSS and generate deferred stylesheets.

Deferring Stylesheets

How precisely will we make the CSS to be non-blocking? We all know that it shouldn’t be referenced within the HTML head component when the web page HTML is first downloaded. Demian Renzulli has outlined this technique in his article.

There’s no native HTML method (as of but) to optimize or defer the loading of render-blocking assets, so we have to use JavaScript to insert the non-critical stylesheet into the HTML markup after the preliminary render. We additionally must guarantee that these kinds get loaded within the non-optimal (render-blocking) manner if a consumer is visiting the web page with JavaScript not enabled within the browser.

<!-- Deferred stylesheet -->
<hyperlink rel="preload" as="type" href="https://smashingmagazine.com/2021/08/refactoring-css-optimizing-size-performance-part3/path/to/stylesheet.css" onload="this.onload=null;this.rel="stylesheet"">

<!-- Fallback -->
  <hyperlink rel="stylesheet" href="https://smashingmagazine.com/2021/08/refactoring-css-optimizing-size-performance-part3/path/to/stylesheet.css">

With hyperlink rel="preload" as="type" makes positive that the stylesheet file is requested asynchronously, whereas onload JavaScript handler makes positive that the file is loaded and processed by the browser after the HTML doc has completed loading. Some cleanup is required, so we have to set the onload to null to keep away from this operate operating a number of instances and inflicting pointless re-renders.

That is precisely how Smashing Journal handles its stylesheets. Every template (homepage, article classes, article pages, and many others.) has a template-specific vital CSS inlined inside HTML type tag within the head component, and a deferred foremost.css stylesheet which incorporates all non-critical kinds.

Nonetheless, as an alternative of toggling the rel parameter, right here we will see the media question being switched from the mechanically deferred low-priority print media to the high-priority all attribute when the web page has completed loading. That is another, equally viable method to defer loading of non-critical stylesheets.

<hyperlink href="https://smashingmagazine.com/css/main.css" media="print" onload="this.media="all"" rel="stylesheet">

Splitting And Conditionally Loading Stylesheets With Media Queries

For the instances when the ultimate stylesheet file has a big file dimension even after the aforementioned optimizations have been utilized, you could possibly cut up the stylesheets into a number of information based mostly on media queries and use media property on stylesheets referenced within the hyperlink HTML component to load them conditionally.

<hyperlink href="https://smashingmagazine.com/2021/08/refactoring-css-optimizing-size-performance-part3/print.css" rel="stylesheet" media="print">
<hyperlink href="cellular.css" rel="stylesheet" media="all">
<hyperlink href="pill.css" rel="stylesheet" media="display and (min-width: 768px)">
<hyperlink href="desktop.css" rel="stylesheet" media="display and (min-width: 1366px)">

That manner, if a mobile-first method is used, kinds for bigger display sizes received’t be downloaded or parsed on cellular units that might be operating on slower or unreliable networks.

Simply to reiterate, this technique must be used if the results of the beforehand talked about optimization strategies leads to a stylesheet with suboptimal file dimension. For normal instances, this optimization technique received’t be as efficient or impactful, relying on the person stylesheet dimension.

Deferring Font Recordsdata And Stylesheets

Deferring font stylesheets (Google Font information, for instance) is also helpful for preliminary render efficiency. We’ve concluded that stylesheets are render-blocking, however so are the font information which are referenced within the stylesheet. Font information additionally add fairly a little bit of overhead to the preliminary render efficiency.

Loading font stylesheets and font information is a fancy subject and diving into it could take a complete new article simply to clarify all viable approaches. Fortunately, Zach Leatherman has outlined many viable methods on this superior complete information and summarized the professionals and cons of every method. For those who use Google Fonts, Harry Roberts has outlined a technique for the quickest loading of Google Fonts.

For those who determine on deferring font stylesheets, you’ll find yourself with Flash of Unstyled Textual content (FOUT). The web page will initially be rendered with the fallback font till the deferred font information and stylesheets have been downloaded and parsed, at which level the brand new kinds can be utilized. This transformation might be very noticeable and may trigger format shifts and confuse customers, relying on the person case.

Barry Pollard has outlined some methods that may assist us take care of FOUT and talked concerning the upcoming size-adjust CSS function which can present a neater, extra native manner of coping with FOUT.

Server-Aspect Optimizations

HTTP Compression

Along with minification and file-size optimization, static belongings like HTML, CSS information, JavaScript information, and many others. HTTP compression algorithms like Gzip and Brotli can be utilized to moreover scale back the downloaded file dimension.

HTTP compression must be configured on the server which is dependent upon the tech stack and config. Nonetheless, efficiency advantages might differ and will not have as a lot influence as customary stylesheet minification and optimization, because the browsers will nonetheless decompress the compressed information and need to parse them.

Caching Stylesheets

Caching static information is a helpful optimization technique. Browsers will nonetheless need to obtain the static information from the server on the primary load, however as soon as they get cached they’ll be loaded from it instantly on subsequent requests, dashing up the loading course of.

Caching might be managed through Cache-Management HTTP header on the server stage (for instance, utilizing the .htaccess file on an Apache server).

With max-age we will point out how lengthy the file ought to keep cached (in seconds) within the browser and with public, we’re indicating that the file might be cached by the browser and every other caches.

 Cache-Management: public, max-age=604800

A extra aggressive and efficient cache technique for static belongings might be achieved with immutable config. This tells the browser that this explicit file won’t ever change and that any new updates will end result on this file getting deleted and a brand new file with a special file identify will take its place. This is named cache-busting.

Cache-Management: public, max-age=604800, immutable

With out a correct cache-busting technique, there’s a danger of shedding management over information that get cached on the consumer’s browser. That means that if the file have been to alter, the browser received’t be capable to know that it ought to obtain the up to date file and never use the outdated cached file. And from that time on, there may be just about nothing we will do to repair that and the consumer can be caught with the outdated file till it expires.

For stylesheets, that would imply that if we have been to replace HTML information with new content material and parts that require new styling, these kinds received’t show as a result of the outdated stylesheet is cached with no cache-busting technique and the browser received’t know that it has to obtain the brand new file.

Earlier than utilizing a caching technique for stylesheets or every other static information, efficient cache-busting mechanisms must be applied to forestall outdated static information from getting caught within the consumer’s cache. You should utilize one of many following versioning mechanisms for cache-busting:

  • Appending a question string to the file identify.
    For instance kinds.css?v=1.0.1. Nonetheless, some CDNs can utterly ignore or strip the question string from the file identify and ensuing within the file getting caught within the consumer’s cache and by no means updating.
  • Altering the file identify or appending a hash.
    For instance kinds.a1bc2.css or kinds.v1.0.1.css. That is extra dependable and efficient than appending a question string to the file identify.

CDN Or Self-hosting?

Content material Supply Community (CDN) is a gaggle of geographically distributed servers which are generally used for the dependable and quick supply of static belongings like pictures, movies, HTML information, CSS information, JavaScript information, and many others.

Though CDNs may look like an amazing different to self-hosting static belongings, Harry Roberts has accomplished in-depth analysis on the subject and concluded that self-hosting belongings are extra helpful for efficiency.

“There actually may be very little cause to go away your static belongings on anybody else’s infrastructure. The perceived advantages are sometimes a fantasy, and even when they weren’t, the trade-offs merely aren’t price it. Loading belongings from a number of origins is demonstrably slower.”

That being stated, I’d suggest self-hosting the stylesheets (font stylesheets included, if attainable) by default and transferring to CDN provided that there are viable causes or different advantages to doing so.

Auditing CSS File Measurement and Efficiency

WebPageTest and different related efficiency auditing instruments can be utilized to get an in depth overview of the web site loading course of, file sizes, render-blocking assets, and many others. These instruments can provide you an perception into how your web site hundreds on a wide selection of units — from a desktop PC operating on a high-speed community to low-end smartphones operating on sluggish and unreliable networks.

Let’s do a efficiency audit on a web site talked about within the first article from this sequence — the one with the 2MB of minified CSS.

First, we’ll check out the content material breakdown to find out which assets take up essentially the most bandwidth. From the next charts, we will see that the photographs take up most requests, which means that they should be lazy-loaded. From the second chart, we will see that stylesheets and JavaScript information are the most important when it comes to file dimension. It is a good indication that these information must both be minified and optimized, refactored, or cut up into a number of information and loaded asynchronously.

Two charts showing the content breakdown by MIME type

Content material breakdown by MIME kind (on the primary view). (Giant preview)

We will draw much more conclusions from the Internet Vitals charts. By looking a the Largest Contentful Paint (LCP) chart, we will get an in depth overview of render-blocking assets and the way a lot they have an effect on the preliminary render.

We might already conclude that the web site stylesheet can have essentially the most influence on the LCP and loading stats. Nonetheless, we will see font stylesheets, JavaScript information, and pictures referenced contained in the stylesheets which are additionally render-blocking. Understanding that we will apply the aforementioned optimization strategies to scale back the LCP time by eliminating render-blocking assets.

the Largest Contentful Paint chart

A chart for Largest Contentful Paint which occurs at 8561ms. Discover the orange bulb on the timeline within the listing of assets — these assets are blocking rendering. (Giant preview)


The refactoring course of isn’t full when the code well being and high quality have been improved and when codebase weaknesses and points have been mounted. Refactored codebase ought to end result within the similar or improved efficiency in comparison with the legacy codebase.

Finish customers shouldn’t expertise efficiency points or lengthy loading instances from the refactored codebase. Fortunately, there are lots of strategies on the market to guarantee that the codebases are each strong and performant — from the easy minification and optimization strategies to the extra complicated strategies like eliminating render-blocking assets and code-splitting.

We will use numerous efficiency auditing instruments like WebPageTest to get an in depth overview of loading instances, efficiency, render-blocking assets, and different components so we will tackle these points early and successfully.


Smashing Editorial
(vf, yk, il)

Supply hyperlink

Leave a Reply