15 Ways to Improve Google Ranking and Site Load Speed

Arsen K

August 3, 2021

Page speed is a big ranking factor for Google. Google has indicated that the site speed is one of the signals it uses to rank web sites. Here's what you can do to improve it:

  1. Reduce the number of requests your site makes
  2. Serve content more quickly using caching and compression techniques
  3. Use CSS and JS to load scripts in the background
  4. Respond quickly to user inputs like typing in text boxes, clicking links, etc
  5. Minimize render-blocking JavaScript and CSS in above-the-fold content
  6. Avoid landing page redirects (301 or 302)
  7. Implement server side rendering whenever possible
  8. Reduce the size of your tracking pixel by removing Google Analytics from your site.
  9. Use smaller opaque GIF files instead of large images
  10. Optimize your CSS for performance
  11. Optimize your images for performance
  12. Avoid CSS animations wherever possible
  13. Avoid Javascript animations
  14. Don't use CSS animations for anything that should happen instantly
  15. Avoid using CSS transforms whenever possible

1. Reduce the number of requests your site makes

The way you can reduce the number of requests you site makes is by using a Content Delivery Network (CDN), and hosting your images on the same server as the one you host your website. And also using CSS and JavaScript to load scripts in the background while users are still loading your page's assets, thereby eliminating their need for a full page load before they see them on screen.

2. Serve content more quickly using caching and compression techniques

When it comes to serving content more quickly, you can serve cacheable static resources (such as images) without an extra round trip to the server by using a CDN in front of web servers (which often have static assets mounted via NFS). You can also compress those files while they're being served, which reduces network bandwidth requirements (and thus delays). You'll want to use Gzip compression as it's supported by nearly every browser and server. You can also minimize render-blocking JavaScript and CSS in above-the-fold content.

3. Use CSS and JS to load scripts in the background

Use CSS and JS to load scripts in the background while users are still loading your page's assets, thereby eliminating their need for a full page load before they see them on screen. You can also make sure people never see your site's markup without its assets by using a prefetch resource hint (the link rel="prefetch" attribute), which lets you load CSS and JS files in the background while users are still loading your page's assets, thereby eliminating their need for a full page load before they see them on screen.

4. Respond quickly to user inputs

Respond quickly to user inputs like typing in text boxes, clicking links, etc., so they're not waiting for a response that may never come because it depends on server response time or having to wait for content delivery over a slow connection with high latency (ping time). You can also reduce how quickly Google's browser will display nothing but a white screen by using server-side rendering whenever possible so users aren't waiting for the initial render of your site's markup before they begin interacting with it.

5. Minimize render-blocking JavaScript and CSS in above-the-fold content

The best way to do this is to inline your CSS whenever possible. You can do this by using content delivery networks like CDNs, so your CSS doesn't have to travel all the way back to the server. You can also minimize browser reflows by combining your Javascript and CSS files into a single concatenated script and using a CSS spritesheet, so they're loaded in parallel. And you can also reduce how much data is downloaded by minifying your JS and images.

6. Avoid landing page redirects (301 or 302)

Avoid landing page redirects (301 or 302), especially three-hops or more, as they can often increase load times due to DNS lookups, TCP connection establishment and overhead, SSL negotiation of session keys, etc.

A 301 redirect is for when you want to move a URL deeper into the site. However, many sites should never put their content behind a 301 redirect, unless it's for user privacy reasons. And you should never have more than one 301 redirect for a website per domain. That may sound like a lot, but the reality is that each page on your site will typically have only one URL to load. Your pages shouldn't be broken up into separate URLs because it can lead to performance issues and unnecessary load time delays.

A 302 redirect is also used for when you're moving content out of your site, but the server will continue to show it with the same URL indefinitely. You should use a 302 redirect when you're moving content over to a different server, permanently. It's preferable to use the HTTP header "Location" as it's more user-friendly than the meta "Refresh" tag.

7. Implement server side rendering

Implementing server side rendering whenever possible means that your pages will show up faster by not having to wait for a full HTML response. And it means all the information of your page is loaded in parallel and parsed before the HTML response is rendered (so it's ready to be displayed instantly).

The key to rendering HTML on the server is something called asychronous JavaScript, which parses and renders HTML at the same time as it's received, so everything can be done on a single thread. The simplest way to load this on browsers that don't support it out of the box is by using a polyfill. There are many different polyfills that you can use (yep, more plugins), but the best way to make sure you're using the right one is by using the HTML5 Shiv from Modernizr.

8. Reduce the size of your tracking pixel by removing Google Analytics from your site

The default tracking code for Google Analytics is rather large, which can have a potential negative performance performance impact, especially if you are on shared hosting. One of the alternatives is to remove Google Analytics from your web site. Alternatively, you should only let Google Analytics load after all of your other content has finished loading via code, or you can also use a Javascript timer to run it in the background. The final option is to look for a lighter Google Analytics alternative. I recommend checking out our 70 Google Analytics alternativesarticle or trying PrivateAnalytix for free for 14 days.

The PrivateAnalytix lightweight tracking pixel is less than 3KB in size, which is 8x smaller than the Google Analytics tracking pixel. This will ensure that you pass less data to with every load, improving your site load speed.

9. Use smaller opaque GIF files instead of large images

You should use PNG or GIF image formats instead of JPEGs whenever possible, as they have smaller file sizes and the GND pixel format is supported, which means there is no perceptible delay when looking at a transparent PNG image on a slow connection (where PNGs have lower overhead than JPEGs).

10. Optimize your CSS for performance

CSS is really sensitive to changes in performance. This is because CSS can be parsed differently by each browser, and it can also be optimized in various ways (by the browser or a tool such as YSlow or PageSpeed). This means that just because one CSS change might make a big difference for one site doesn't necessarily mean it will do the same for another site. So you have to test your optimizations on your own site first before thinking that they'll work everywhere else as well.

11. Optimize your images for performance

Images are the single biggest issue with performance. Images that are heavily used can take a while to load, and if they're not optimized for performance, then they will end up being the slowest part of your page and cause a lot of problems.

Using images that are smaller in file size is better for performance because it requires less data to be transferred from the server to the browser over a slow connection and that means faster page rendering (less time-to-first-byte). I recommend compressing your existing images with TinyPNG or using PNG or GIF images instead of JPEGs, as they have smaller file sizes and they also don't introduce perceptible delay when looking at a transparent PNG image on a slow connection (where PNGs have lower overhead than JPEGs).

12. Avoid CSS animations

CSS animations cause issues because the browser has to re-layout the DOM when it's done coordinating all of the CSS properties. This is where we see a perceived latency, and it also slows down page rendering times (by causing them to be longer).

For example, if you have a 10-pixel wide content box that animates to 25 pixels wide, at 50 milliseconds per animation iteration, then in total that will result in 50 milliseconds extra time to render your page.

13. Avoid Javascript animations

Javascript animations also cause the browser to have to re-layout the DOM when it's done coordinating all of the CSS properties. This means that like CSS animations, you will see a perceived latency, and it will slow down page rendering times (by causing them to be longer). For example, if you have a 10-pixel wide content box that animates to 25 pixels wide at 50 milliseconds per animation iteration, then in total that will result in 50 milliseconds extra time to render your page.

14. Don't use CSS animations

Converting an image to the placeholder and then scrolling it vertically a couple of times is a huge performance problem as it will not only slow down the page, but also cause the browser to have to re-layout the DOM whenever users move the cursor over the image and when they scroll.

Instead, just load your images in a container, which is what you do with all other image files anyway (so why not just load them as containers directly), and then have your application change one of its properties (e.g. scaleY , opacity or transform ) whenever it needs to then animate that property from 0% to 100%.

Lazy loading is a very common solution to the problem of "what do you do with images that are not being viewed?" but it's really bad for performance because it means the browser has to re-download all of your images every time you want to view them, and it also means they're going to take up space in your User Interface (i.e. on page load). You can also lazy load images using Javascript and DOM manipulation, which is usually a better option, but again this is still going to be slower than loading them upfront, due to render-blocking issues.

15. Avoid using CSS transforms

Similar to CSS animations, the browser has to re-layout the DOM whenever you use a CSS transform. This means that if you have an element that gets transformed (e.g. moved, rotated or scaled) 90 degrees for each animation iteration, then in total that will result in 90 milliseconds extra time to render your page.

Ready to improve your conversions and spend less time guessing?

Sign up for PrivateAnalytix. We provide you with a full 60-day satisfaction guarantee. If you are not completely satisfied with us within 60 days, we will provide you with a full refund.

Sign Up Now