Why bother to optimize images for web? Let me ask you this; when was the last time you saw a website without any images on it? “Never” would be the right answer. 🤷♂️ Images are just too essential. And this isn’t even about that cringe-worthy stock photo to go along your “10 online marketing tips” post. Images are useful for multiple purposes. Think layouts, design element, logos, profile pictures, and, yes, blog images too.
Frankly, you can’t build a website in 2023 without using at least a handful of images on it. That being said, images are not that straightforward to figure out for a website owner.
Even setting aside the challenges of what images to use and where, there are also issues of displaying those images from a purely technical point of view:
- How to deliver responsive images across multiple devices?
- How to make them look great on all those devices?
- And, most importantly, how to make sure they load in decent time?
These are the questions we’re answering today. Here’s your ultimate guide on how to optimize images for web and make them look great on all devices.
👋 Why listen to us?
Images have been a critical topic for us lately, and that’s because of one of the newer tools in our family – Optimole.
Optimole is a set-it-and-forget-it image optimization service & tool. We consider it to be the best such solution on the web, and we can prove it! But that’s a talk for another time. Either way, over the years, we’ve learned a lot about how to optimize images for web properly. We want to share some of that knowledge with you today.
🤔 Why you should optimize images on your site
Images, apart from looking great, also consume a significant amount of disk space and bandwidth. More specifically, images account for anything from 30%-85% of the size of a standard web page.
That is huge – and it’s not like removing images is an option – so the best thing we can do instead is learn how to optimize images for web in a way that simply takes up less disk space.
The gains can be huge, and especially when dealing with repeated images – images that need to be loaded on every individual web page. Those are things like backgrounds, design elements, logos, icons, splash screens, etc. Sometimes optimizing just one background image can result in cutting your page size by 70%+.
See this example:
But hold on, it gets worse! If the general image performance struggles weren’t enough, there’s also the mobile realm 📱, and it brings a completely new set of challenges:
First off, you probably shouldn’t display the same set of images to your desktop visitors and your mobile visitors. The contexts are just vastly different – this includes the screen sizes, orientation (usually in portrait) and even the mindset of the person reading.
Moreover, data suggests that mobile designs with fewer images tend to perform better in terms of conversions.
When all put together, there are a couple of things that we need to take care of when delivering responsive images across multiple devices:
- first, optimize images for that specific device
- make sure the images are compressed to the maximum acceptable level to guarantee the fastest loading times
- display the optimal number of images considering the device and screen
🚶♂️ How to optimize images for web and deliver them across all device types
Getting your images processed optimally and then delivered to the visitor as quickly as possible has several components to it. In this guide, we’ll go through them all:
🍁 Pick the correct format
Let’s start with the age-old question: PNG or JPG?
Most people say “JPG all the time!” But that’s not really correct:
PNG vs JPG
Yes, most of the time, or at least in the most common scenarios for what we might need images, JPGs take up less disk space and therefore less bandwidth as well.
But the keyword here is “the most common scenarios.” In fact, if what you have is a complex image with a lot of colors and color transitions (aka. a lot of “color information”), then JPGs are indeed going to be better. Think standard photos. Those work better as JPGs.
However, if you have an image that’s a bit simpler, PNG will win all the time.
Consider the following example. Here are four images:
- image 1-a is 312 KB
- image 2-a is 196 KB
Try guessing the sizes of the other two images…
Now for a bit more timely question: SVG? WebP?
SVG and WebP
SVG and WebP are a bit less common image types on the web, but they are both great as long as you’re using them as they should be used. Let me clarify:
- SVG is an XML-based vector image format. The contents of the image can be defined in a simple XML file – the same XML file you’d use for other basic data processing purposes. This makes SVG a good format, as long as you’re dealing with a simple vector image.
- WebP is a newer format by Google. They brag that WebP is 25-34% smaller in size than comparable JPEGs, and 26% smaller than comparable PNGs.
So what’s the catch? Can you optimize images by turning them all into SVGs and WebPs?
First, SVG. Basically, use SVG only if (a) the image can be saved as SVG efficiently, and (b) if you don’t mind people taking that SVG and modifying it.
As I said, SVG is XML-based, which means that modifying SVG graphics is really easy to do. This is not always something you want – especially when dealing with your brand’s logo or other crucial graphics.
In most scenarios, SVGs are not a format you’ll use very often.
Now, onto WebP. The format is great, and in most cases, it does indeed save a lot of disk space just as promised. Check out these two example images from our article covering Sketch alternatives for Windows::
- the original JPG version is 204 KB
- the WebP is 58 KB
When I first wrote this article, not all browsers supported WebP. In fact, at the time, depending on what browser you were using, you may have not even seen the WebP image I used above.
However, the internet has rapidly adopted the format, and as of the time of writing, WebP has a 97% market share among web browsers. This includes Google Chrome, Safari, Firefox, Edge, and Opera.
With that said, be mindful of the fact that if you, or your site visitors, are surfing the web using an older version of any of those browsers, then WebP may not render properly. By “properly” I mean “at-all”, as in the images won’t load.
In addition to web browsers adopting WebP en masse, starting with WordPress 5.8 and above, WordPress also began to support WebP by default. This means that as long as you are using WordPress and have it updated to the latest version, then you won’t need to insert any sort of special code or use a third-party plugin just to use WebP images.
I do recommend using WebP freely, but particularly whenever you’re dealing with images that appear on multiple pages within your site, or images that are excessively large. You’ll need every tool at your disposal to reduce their size some in some way, and the WebP format is an effective way to do it.
You can save images as WebP in Photoshop, or use a tool like XnConvert (free).
You may also be interested in:
- A/B Testing in WordPress: What It Is and How to Get Started
- 15+ Best Free SEO Tools for When You’re Just Starting Out
- 3 Steps How to Do Keyword Research With ChatGPT
🗜️ Compress images
Image compression is like magic. Let me show you:
This is the same JPG image, only saved at a different level of compression (often referred to as level of quality):
If you’re like most people then the first three look the same to you. The fourth one starts looking “a bit worse.” (Right click and “Open Image in New Tab”)
Here’s how much disk space each of these images takes:
- 100% quality: 969 KB
- 95%: 439 KB
- 85%: 186 KB
- 50%: 102 KB
Huge, right?! You can go from ~1 MB to ~500 KB with no noticeable loss in quality at all, just by changing the compression from 100% to 95%.
This JPG compression can be handled fairly automatically by various tools, which is great news. However, not all images are created the same, so sometimes you might get okay-looking images next to bad-looking images even though they underwent the same compression process.
Overall, you can take a leap here and downscale the quality of your JPGs pretty heavily. The truth of the matter is that your site visitors don’t care for crisp images everywhere.
Okay, I should clarify; yes, when you want to show them something – like an image that’s key to a piece of content, e.g., product images, hotel room photos – then sure, those ones should be crisp.
But in other areas, you can be a bit more relaxed. For instance, backgrounds don’t need to be 100% crisp. In general, all images that the visitor is not directly engaged with can be lower in quality.
Two of my favorite tools that can help you here are:
ImageOptim for desktop compression on Mac. You can just grab an image from the desktop, drag and drop it onto ImageOptim, and then the tool does its magic and overwrites the source image when done.
Then, you can get that image and upload it to your site normally.
The second tool is Optimole. This tool pretty much redefines how handling images is done on websites. For the purpose of this discussion, let’s just say that it’s really effective when you want to optimize images that are in your media library.
Now onto PNGs. Just like JPGs, PNGs can be compressed as well. But this time, there’s no downside in terms of loss in quality. PNGs can be compressed effectively using lossless algorithms.
In other words, compress your PNGs, always!
Check out these three images:
They look the same, but they actually take up:
- 346 KB
- 215 KB
- 100 KB
Try guessing which is which.
Three tools to compress your images and make them smaller:
- ImageOptim again. But this one takes a lot of time with PNGs, so if you have many of them to process, you might want to make yourself a cup of coffee while the tool is working.
- ImageAlpha. Much quicker than ImageOptim. It’s my go-to desktop solution for PNGs.
- Optimole. Unsurprisingly, Optimole handles PNG compression as well. Everything happens on autopilot.
📏 Serve images of the correct dimensions
This is perhaps the most crucial aspect of the whole “responsive images” riddle. As we know, there are tens if not hundreds of different screen sizes out there, and we somehow must make sure that our images are going to look great on all of them.
The easy solution? Serve a big image … it can always be scaled down, right? Well, technically, that is correct, but in practice, this will waste a lot of bandwidth and make your site load really slowly on most devices.
A better solution is to scale all images to the correct sizes that are preferable by the most common devices and then serve them accordingly.
As you would expect, you do need different versions of the same image to achieve this.
One of the ways to go about this is to start with your design’s base width and the biggest image size that can be used, and then scale down from there for some common devices and breakpoints.
For example, most websites don’t go above the 1100 px mark for content block width, so you can assume that the max image that can be displayed in that case is 1100 px in width as well.
Then, you can create breakpoints for 800 px and 550 px (common values) to cover tablet and mobile scenarios. While this won’t give you 100% perfect results on all devices, you’re at least optimizing to a reasonable extent and keeping your images under control.
With this behind you, you now must create a handful of different versions of each image that you want to use on your site.
Here’s an example of how to handle the actual display code:
<img src="image.jpg" srcset="image-550.jpg 550w, image-800.jpg 800w, image-1100.jpg 1100w" sizes="(max-width: 1100px) 1100px, 100vw" />
The magic of the
srcset attribute is that the browser looks at what’s in it and then picks the best image based on the device being used.
One more customization that you can see above is the
sizes attribute. This one tells the browser how the image should behave on certain screens. In this scenario, the image is going to be 1100 px when viewed on viewports larger than 1100 px, while on smaller devices it’s going to take up the whole viewport.
This sort of solution to optimize images makes sure that the image doesn’t take up a whole 3840px-wide 4K screen. However, it will still occupy the entire screen when viewed on mobile.
This effective use of the
sizes attribute is how you make your images truly responsive.
⭐ Pro trick: Go for images that are 10% smaller in dimensions than what’s needed, and then let the browser scale them up. This will save you some additional space and bandwidth. For example, if you require an image that’s 500×500 px, you can scale your image to 450×450 px, and then let the browser scale it up to 500. This does depend on the image, but in most cases, the user won’t notice.
📺 Optimize images for Retina and HiDPI screens
The other end of the image dimension spectrum is about HiDPI-friendly images.
The story is that desktop screens keep getting bigger and bigger, and their pixels keep getting packed more and more densely. It’s not uncommon these days to have a 4K screen packed into a 15-inch laptop. The 4K resolution is 3840×2160 px, so each of those pixels has to be really tiny.
This creates problems for websites. Basically, if your site was defined as 1100 px wide then, under normal conditions, it would only take up roughly 25% of the available screen real estate of a 4K screen. This is not optimal. Luckily, things don’t work like that.
To avoid the issue, those high-res screens act as if they were half the size (I’m oversimplifying, but hear me out). So, instead of your 1100 px wide website occupying a small portion of a HiDPI screen, it gets scaled up to double that, taking up 2200 px and filling the screen much better.
This process allows screens to keep getting sharper and sharper without making everything look tiny in the process.
However, this practice is not without its faults. Chiefly, your images take a huge hit. Text is easy to scale up without losing quality. Fonts are immune to scaling. Images are not. As a direct result, every image that’s not ready for HiDPI screens will look blurred, heavily!
To fix that, you must deliver scaled images for each of the zooming ratios. Here’s some simple code:
<img srcset="img-orig.jpg, img-2x.jpg 2x, img-3x.jpg 3x" src="img-orig.jpg" />
(If the browser doesn’t support
srcset, the standard
src will be used.)
Now, when I say “scaled images,” I actually mean that you should start from the other end. Begin with a huge image (label it 3x), then scale it down and make it smaller (to 2x), and finally make it 1x and use that as the default image.
⌛ Defer image loading
This is simple in principle; all images that are above the fold should be loaded immediately (on page load). Everything else can be deferred for later, and even “lazy loaded.”
Lazy loading is image loading on demand. I.e., images get loaded only a split second before the user needs them – not sooner, not later. And that “not sooner, not later” part is key here.
In an ideal scenario, the image should be loaded just before it gets scrolled into the viewport. Meaning, the user shouldn’t have to see a placeholder before the image appears. If that happens, they might scroll pass the image without it managing to load in time – not a great way to optimize images.
🌐 Deliver images via a CDN
A Content Delivery Network is like a cheat code for site speed. You’re cheating because you’re not as much making your site faster, as you’re telling someone else to take the load and deliver the site’s data to the visitor for you.
👉 We talk about CDNs more in-depth in a separate post, check it out in the related articles list at the top of the page..
The TL;DR is that CDNs take advantage of a network of servers that all hold a copy of your site and then deliver it to the visitor from the nearest available location. This is always going to be faster than delivering from your main server.
Image CDNs work pretty much the same, but as their name implies, they have a hyper-specific focus, which is to optimize images, and images only.
Most of the time, the operation is seamless from your point of view. All images on your site get replaced by their CDN-hosted versions (meaning that the image URLs change).
- Jetpack has a popular image CDN built right in. You can use it for free, which is great. The main limitation is that it only works with the images in your posts, pages, and your featured images. It doesn’t work for any images that make up your design (parts of the theme, layout, etc.). Those are the images that could really use some CDN-ing.
- Optimole has a CDN built-in as part of the main image optimization feature. This one is not limited to your posts and pages only.
🐌 Serve smaller images to users on slow connections
Not only screen size matters when deciding what type of image the user should see. Probably even more importantly, if they’re on a slow internet connection, they really don’t want to wait 10 seconds for an image to load.
In these scenarios, it’s a lot better idea to downgrade the quality of your images in exchange for load time. Users on slower connections will appreciate that they can see the images at all.
You can make this happen by utilizing the Network Information API. Here’s a cool tutorial on how it all works if you want to implement it by hand.
If you’d prefer it to be handled on autopilot, again, Optimole!
🧰 Tools tools tools!
Along the way, I mentioned a number of tools that you can use to make your site’s image delivery more effective. Here’s a summary of those:
📚 Further reading:
- Imagify vs WP Smush vs ShortPixel vs Optimole: Which is best for optimizing WordPress images? Head-to-head comparison
- Free images for blogs – how to get them & use them effectively (warning! non-obvious advice, data-backed)
Here’s a summary of all the individual lessons shared above:
- Lesson #1:
- Don’t always go for JPG. Predict how big the image is going to be based on its contents, and then use the correct image type.
- Lesson #2:
- Don’t bother using SVGs at all if you want to optimize images quickly. The time you’ll waste creating them won’t pay off (although feel free to disagree). PNGs are going to be much quicker to use and not much worse in terms of disk space consumption.
- Use WebP as often as possible, but especially when dealing with images that appear on multiple pages or images that are unusually large. If you don’t want to convert your images to WebP manually, then you can use a plugin like Optimole, which automatically serves WebP images to your site visitors by default.
- Lesson #3:
- Compress your JPGs to reach an acceptable level of quality vs disk space. Compress your PNGs always.
- Lesson #4:
- Use the correct image sizes for your design. Create breakpoints. Create multiple versions of the same image to cover the breakpoints. Use the
sizesattributes when displaying the images.
- Lesson #5:
- Make sure your logos, branding images, and all images used in your posts and pages are ready for HiDPI screens.
- Lesson #6:
- Lazy load images that are below the fold.
- Lesson #7:
- Hook up your site to an image CDN (Jetpack or Optimole) or a general CDN (MaxCDN / StackPath).
- Lesson #8:
- Serve smaller and more compressed images to users on slower internet connections.
Let me know what you think of the whole challenge to optimize images for the web as much as possible. Also, what are you doing with your images to make them load faster? Share in the comments.
Don’t forget to join our crash course on speeding up your WordPress site. Learn more below:
Layout, presentation, and editing by Karol K.
* This post contains affiliate links, which means that if you click on one of the product links and then purchase the product, we’ll receive a small commission. No worries though, you’ll still pay the standard amount so there’s no additional cost on your part.