October 10th, 2019
We constantly hear about the importance of keeping websites lean and fast. A fast-loading website makes users more satisfied, and satisfied users spend more time and money on your website. However, website optimization is a complex task, as there is no one silver bullet to fix all of the issues causing poor performance.
We also hear that addressing the performance of images is a low hanging fruit if you want to improve your site’s user experience, However, anyone who has gotten their hands dirty trying to optimize images and cover major use cases and scenarios with responsive images knows that the complexity of this task escalates quickly. For most medium to large sites, image optimization is not a task suited to humans. This is why image content delivery networks (CDN) exist.
An image CDN is indeed a content delivery network built especially for images. Just like the name suggests. So, why would we need a special CDN to serve images? Why not use a regular CDN to serve static files? Short answer is that images are not static files…
Most image CDNs treat an image as dynamic content by optimizing the image in different ways based on the context where the image is consumed.
Explained a bit differently; if you’re using responsive images on your website, an image cdn will automatically generate the derivatives of the image according to the sizes specified in the markup, usually based on some URL parameters. For example, the below code selects from 3 derivatives specified in the srcset attribute based on 3 breakpoints:
<img src="//i.foo.com/image.jpg" alt="cat" srcset="//i.foo.com/image.jpg?width=320 320w, //i.foo.com/image.jpg?width=640 640w, //i.foo.com/image.jpg?width=1280 1280w" sizes="(max-width: 480px) 100vw, (max-width: 900px) 33vw, 254px">
This way, the developer or designer doesn’t have to worry about creating all the image versions beforehand. Which is very good news, because the number of derivative images may quickly grow exponentially based on many breakpoints, image formats, and screen resolutions. And that is before we’ve started talking about art direction.
Dynamic Image Optimization on Autopilot
Now that we’ve seen how an image CDN can create different sizes of an image on the fly, let’s examine how this improves web performance.
Before we go further to choose an image CDN for the examples later, it is important to point out the difference between an image CDN and a digital asset management tool (DAM). A DAM, such as Cloudinary, is mostly focused on file management aspect and often allows you to edit images and apply art direction like filters. Usually, these DAMs need a general-purpose CDN in front and there is little support for automation of image optimization tasks.
On the opposite end of the scale is ImageEngine. ImageEngine is the most effective image CDN on the market thanks to its built-in device detection that enables superior image optimization for mobile traffic. Since mobile devices account for more than 50% of the traffic in many countries, ImageEngine truly has an advantage over other CDNs. While most other image CDNs only offer little or no automatic optimization, ImageEngine has a more advanced approach thanks to its focus on mobile traffic. Hence, ImageEngine will be able to produce the best results with less implementation effort and maintenance.
How ImageEngine Improves Web Performance
With ImageEngine handling all image traffic, images are no longer static content. Images are now adapted and served exactly in the size, format, compression rate and resolution needed. Fine. But how do we measure the improvement?
These days, the “go-to tool” for identifying performance issues and measuring performance is Google Lighthouse. Lighthouse is available as a standalone app and in your Chrome developer tools.
We’ll run a performance audit on an e-commerce demo page listing product images.
Step One: Assess Current State
Running the Lighthouse audit on the demo-page we see a number of issues, summarized in a performance score of 98. The best score is 100, so 98 might not seem that bad. Which is true, but pay more attention to the metrics below the score. The performance score is calculated based on a few metrics with varied weighting. The images on our page have direct and indirect impact on these metrics.
In the details of the report, we see a few opportunities related to images listed:
- Properly size images. The images do not have the right pixel size. This is quite common on pages with a responsive or fluid layout.
- Serve images in next-gen formats. For Chrome, this basically means to convert images to the web. Usually, web is a more efficient format than most others when it comes to byte size and decodes speed.
- Efficiently encode images. There is more compression that can be applied to the images before impacting perceived visual quality.
The estimated savings (to the right in the report) are huge. This demonstrates why addressing images is considered a low hanging fruit for performance.
If you haven’t signed up already, create a free ImageEngine trial account. Once you’ve completed signup you can define the image origin (usually your website) and a domain from which you want to serve images from. The image may be something like images.mydomain.com. You point this domain name to ImageEngine with a CNAME record in your DNS, and you’re good to go.
The next step is changing the markup to make the most out of ImageEngine’s automatic features.
If our previous image tag looked like this:
<img class="pic-1" src="images/demo9/img-1.jpg">
Our new image tag will look like this when the ImageEngine domain name is serving the images:
<img class="pic-1" src="https://images.mydomain.com/images/demo9/img-1.jpg">
Because our grid layout is fluid with 4 breakpoints, we might also consider to use responsive images syntax:
<img class="pic-1" src="https://images.mydomain.com/images/demo9/img-1.jpg" sizes="(max-width: 576px) 93vw, (max-width: 768px) 238px, (max-width: 768px) 238px, (max-width: 992px) 148px, 253px" >
Thanks to ImageEngine’s support for Client hints, ImageEngine will now generate the exact pixel size needed. Client hints are additional HTTP headers the browser can send to enable more accurate image resizing. Client hints are currently only supported by Chrome browsers
Step Three: Measure the Improvement
Running the Lighthouse audit again, we see that the score is now 100. But more importantly, look at the improvements in timings. “Time to interactive” for example. 0.7 seconds less waiting for the user in order to interact with the page. All because images are optimized properly.
What does really “optimized” mean in this case? Why is the page faster and user experience better with ImageEngine? Most of the positive impact is due to reduction in byte size of the images. The less bytes, the faster are the images transferred from the host (or ImageEngine’s edge servers) to the browser. Moreover, lighter images are usually faster to decode and render onto the users screen. This is very simplified, but let’s see how much ImageEngine reduces the image payload using WebPageTest.org to compare our demo site with-, and without ImageEngine:
ImageEngine reduces the image payload to only 25% of the original size.
Bonus: Fix Caching
In the continuous hunt for improved performance, you may have seen this alert from Lighthouse.
Lighthouse thinks the images have a too short Time To Live (TTL) -measured in seconds- in the browser cache. By default, ImageEngine passes on the cache directives given by the origin but luckily this can be changed in ImageEngine’s management interface.
Next Step: Automate Image Optimization
We’ve seen how images should no longer can be treated as static content if we want a high performing web site. Because images have such a high impact on website performance, images must be tailored according to the capabilities and context of the browser and user.
A purpose-built image CDN will relieve humans of the responsibility of trying to accommodate all possible combinations of image formats, sizes, and compression levels. Managing image derivatives is not a task for humans as it will quickly grow to become unmanageable.
Using tools like Lighthouse and WebPageTest.org document the positive impact image CDNs like ImageEngine has on important performance metrics.