Optimize Images

Check the GIFs and see if they are using a palette size corresponding to the number of colors in the image. Convert GIFs to PNGs and see if there is a saving. More often than not, there is. Developers often hesitate to use PNGs due to the limited support in browsers, but this is now a thing of the past.

Don’t Scale Images in HTML

Don’t use a bigger image than you need just because you can set the width and height in HTML. If you need <img width=”100″ height=”100″ src=”/pic.jpg” alt=”Image” /> then your image (pic.jpg) should be 100x100px rather than a scaled down 500x500px image.

Make favicon.ico Small and Cacheable

The favicon.ico is a necessary evil because even if you don’t care about it the browser will still request it, so it’s better not to respond with a 404 Not Found. Therefore, make sure it’s small, preferably under 1K; set Expires header a few months in the future.

Avoid Empty Image src

Images with empty string src attribute occur more than one will expect. They cause the same effect: browser makes another request to your server. That’s bad because it cripples your servers by sending a large amount of unexpected traffic, and wastes server computing cycles generating a page that will never be viewed.

Clean Up Your Code

This is an easy step, and should be something you have in the back of your mind when coding a new site. You don’t want your code to look messy, or have any extra div files. The more basic your code is, the faster the loading time. It should look clean crisp and white.
HTML is not the only code that should be clean – make sure your style sheets are in order as well. Keeping things neat and organized should ensure a faster loading time. When implementing large photo files, use a compressed file instead. This will also keep your CSS more clean and help with loading time.

Place Your Stylesheets at the Top

Moving stylesheets to the document HEAD makes pages (appear to be) loading faster. This is because putting stylesheets in the HEAD allows the page to render progressively.
The problem with putting stylesheets near the bottom of the document is that it prohibits progressive rendering in many browsers, including Internet Explorer. These browsers block rendering to avoid having to redraw elements of the page if their styles change. The user is stuck viewing a blank white page.
The HTML specification clearly states that stylesheets are to be included in the HEAD of the page, so the optimal solution is to follow the HTML specification and load your stylesheets in the document HEAD.

Place Your Scripts at the Bottom

The problem caused by scripts is that they block parallel downloads. The HTTP/1.1 specification suggests that browsers download no more than two components in parallel per hostname. If you serve your images from multiple hostnames, you can get more than two downloads to occur in parallel. While a script is downloading, however, the browser won’t start any other downloads, even on different hostnames.
But in some situations it’s not easy to move scripts to the bottom. If, for example, the script uses document.write to insert part of the page’s content, it can’t be moved lower in the page.

Make JavaScript and CSS External

Using external files in the real world generally produces faster pages because the JavaScript and CSS files are cached by the browser. JavaScript and CSS that are inlined in HTML documents get downloaded every time the HTML document is requested. This reduces the number of HTTP requests that are needed, but increases the size of the HTML document. On the other hand, if the JavaScript and CSS are in external files cached by the browser, the size of the HTML document is reduced without increasing the number of HTTP requests.
The key factor, then, is the frequency with which external JavaScript and CSS components are cached relative to the number of HTML documents requested. This factor, although difficult to quantify, can be gauged using various metrics. If users on your site have multiple page views per session and many of your pages re-use the same scripts and stylesheets, there is a greater potential benefit from cached external files.
For front pages that are typically the first of many page views, there are techniques that leverage the reduction of HTTP requests that inlining provides, as well as the caching benefits achieved through using external files. One such technique is to inline JavaScript and CSS in the front page, but dynamically download the external files after the page has finished loading. Subsequent pages would reference the external files that should already be in the browser’s cache.
Many web sites fall in the middle of these metrics. For these sites, the best solution generally is to deploy the JavaScript and CSS as external files.

Avoid Redirects

I know that I have previously recommended using redirects, but the main thing to remember is that redirects slow down the user experience. Inserting a redirect between the user and the HTML document delays everything in the page since nothing in the page can be rendered and no components can start being downloaded until the HTML document has arrived.
One of the most wasteful redirects happens frequently and web developers are generally not aware of it. It occurs when a trailing slash (/) is missing from a URL that should otherwise have one. For example, going to http://example.com/directory results in a 301 response containing a redirect to http://example.com/directory/. This is fixed in Apache by using Alias or mod_rewrite, or the DirectorySlash directive if you’re using Apache handlers.

80% of the end-user response time is spent on the front-end. Most of this time is used in downloading all the components in the page: images, stylesheets, scripts, Flash, etc. Reducing the number of components in turn reduces the number of HTTP requests required to render the page. This is the key speed up your website.

Minimize HTTP Requests

One way to reduce the number of components in the page is to simplify the page’s design. But is there a way to build pages with richer content while also achieving fast response times? Here are some techniques for reducing the number of HTTP requests, while still supporting rich page designs.
Combined files are a way to reduce the number of HTTP requests by combining all scripts into a single script, and similarly combining all CSS into a single stylesheet. Combining files is more challenging when the scripts and stylesheets vary from page to page, but making this part of your release process improves response times.
CSS Sprites are the preferred method for reducing the number of image requests. Combine your background images into a single image and use the CSS background-image and background-position properties to display the desired image segment.
Image maps combine multiple images into a single image. The overall size is about the same, but reducing the number of HTTP requests speeds up the page.

Add an Expires or a Cache-Control Header

There are two aspects to this rule:
* For static components: implement “Never expire” policy by setting far future Expires header
* For dynamic components: use an appropriate Cache-Control header to help the browser with conditional requests
Web page designs are getting richer and richer, which means more scripts, stylesheets, images, and Flash in the page. A first-time visitor to your page may have to make several HTTP requests, but by using the Expires header you make those components cacheable. This avoids unnecessary HTTP requests on subsequent page views. Expires headers are most often used with images, but they should be used on all components including scripts, stylesheets, and Flash components.

Use Gzip Compression

The time it takes to transfer an HTTP request and response across the network can be significantly reduced by decisions made by front-end engineers. It’s true that the end-user’s bandwidth speed, Internet service provider, proximity to peering exchange points, etc. are beyond your control. But there are other variables that affect response times. Compression reduces response times by reducing the size of the HTTP response. Gzipping generally reduces the response size by about 70%.
Starting with HTTP/1.1, web clients indicate support for compression with the Accept-Encoding header in the HTTP request. If the web server sees the respective header in the request, it may compress the response using one of the methods listed by the client. The web server notifies the web client of this via the Content-Encoding header in the response.
Most websites gzip their HTML documents. It’s also worthwhile to gzip your scripts and stylesheets, but many web sites miss this opportunity. In fact, it’s worthwhile to compress any text response including XML and JSON. Image and PDF files should not be gzipped because they are already compressed. Trying to gzip them not only wastes CPU but can potentially increase file sizes. Gzipping as many file types as possible is an easy way to reduce page weight and accelerate the user experience.