Tips for SEOs To More Effectively Communicate with Web Developers

22nd May 2019Lily Ray & Mark Davoli

By Lily Ray, Director SEO and Mark Davoli, Senior Web Developer, at Path Interactive.

As SEO professionals, our success often relies on a web developer’s ability to correctly understand and implement our recommendations. However, there is often a disconnect between our needs and the requirements placed on developers to do their jobs effectively. Understanding the type of information developers need to execute on specific SEO tasks, and developing skills to effectively communicate with developers, is paramount to SEO success.

These are some of the most common requests made by SEOs, and the details web developers require to effectively execute on them.

1. Implementing 301-redirects, often thousands at a time

If an SEO requires that 1,000s of URLs are redirected, developers will likely need to implement regular expressions to make the job more manageable. SEOs are not expected to know how to write regular expressions, as this is usually the job of a developer, but if they can offer assistance, that can help to speed up the process. One way SEOs can help is by identifying patterns in URLs where regex rules could be leveraged, for example, groups of category or product pages.

Most redirect tools allow for the use of regex, with the exception of some poor quality WordPress plugins that only support flat redirects, which shouldn’t be used for large scale site migrations. The right redirect tool will ultimately depend on the CMS and the server environment. In the case of WordPress, Redirection is a great tool that supports regex. But for websites built on other server environments, such as NGinx, Apache, or Windows, each one handles redirects differently, and sometimes redirects need to be done at the server level.

SEOs should know the server environment (which can usually be identified using BuiltWith) before making generic recommendations, such as “add a redirect plugin” or “these redirects can be added to the CMS.” Ideally, SEOs should confirm with the developer whether redirects should be added on the CMS, CDN, or server level.

2. Adding structured data to a webpage

If Schema markup is being added to a brand new site, it’s much easier for developers to add the Schema as part of the site build, as opposed to layering it on after the website has already been coded. Developers benefit from SEOs telling them specifically which page elements require Schema (location, events, etc.) and a link to the respective Schema type on Schema.org, so the developer can figure out the best approach for implementation.

SEOs have largely taken ownership of writing JSON-LD themselves, which is great for speeding up the process of implementing Schema. JSON-LD is generally easiest for developers to implement, but adding inline Schema is usually simple as well. There are some plugins that can assist with the implementation, but they generally only support for basic Schema types, such as Website or Organization.

3. Defer render-blocking JavaScript/CSS in above-the-fold content

SEOs should understand deferring JS/CSS is a complex and nuanced task, and they should ask the developer what’s possible before making a firm recommendation. Many developers have a love/hate relationship with Google’s Page Speed Testing Tool, because sometimes it gives recommendations that are not entirely necessary or that are difficult to implement. It’s better to build a website for speed, and to focus on actual page load times, than it is to focus on Google’s Page Speed score. Page speed tools can also give bad marks to scripts loaded via Google Tag Manager, even though they load asynchronously and have zero impact on actual usability load time. For this reason, treat page speed testing tools as guides, not as the only source of information on website performance.

It is also important to understand your target audience when assessing the individual page speed requirements of a given website. For a corporate website primarily used by business owners on desktop, speed is less important than a new website with a largely mobile audience. The Page Speed Testing Tool is based off of a mobile user using a 3G connection, and this may not be the primary audience for many businesses whose customers may be primarily using 4G LTE connections or WiFi to access their websites.

When it comes to deferring render-blocking scripts to load after important page content, this must be done in a way that doesn’t inadvertently break the site. For example, if a WordPress website uses plugins by less reputable developers who are not building in the recommended format for modern technologies, and then jQuery is placed in the footer, this could create JavaScript errors. Some plugin developers write their code looking for the code in the header, so if you put it into the footer, the plugin won’t work as intended.

On more modern websites, it’s easier to plan for deferring CSS/JavaScript or to load these files asynchronously so the initial content loads simultaneously with the JavaScript.

4. Implement lazy loading on images

Lazy loading has become very popular and is great for page speed and, in turn, SEO. But implementing it can be complex for some websites. In some cases, lazy loading can be implemented easily via plugins, such as the WordPress plugin WP Rocket. Using WP Rocket, webmasters can turn on the lazy loading feature and instantly have all images, JavaScript iframes, and videos lazy load.

Google recently rolled out a new HTML attribute for lazy loading, but before SEOs begin recommending this to their clients, it’s important to keep in mind that this attribute is not compatible with most browsers ‚Äì it only works with modern versions of Chrome. So, leveraging this HTML attribute requires that you build with backward compatibility in mind to achieve lazy loading in all browsers. Many businesses have website visitors still using older browsers, such as IE 11, so lazy loading would have to be implemented via JavaScript for these users to benefit from that feature.

It is extremely important to understand who your target is before making recommendations about how to implement new features that impact SEO performance. SEOs can help developers by using analytics data to inform them about which browsers and browser versions are primarily used by the website’s visitors. This knowledge can help developers make better decisions about which features they can or cannot use, and the extent to which older browsers need to be supported.

5. Minifying JS or CSS files

This is a straightforward recommendation that shouldn’t take any good developer by surprise. Developers should be able to do this easily, and content delivery networks (CDNs) like CloudFlare can do this with the click of a button. It is also recommended to minify HTML on production servers.

6. Implementing a CDN for images and videos

CloudFlare is the recommended CDN to best accomplish SEO tasks. For example, CloudFlare allows all static content to be delivered via CDN. Also, CloudFlare doesn’t change the URL path, so you can ensure you are using SEO-friendly image names.

If you’re hosting on your own website and just want to use a CDN for images or videos, 3rd party plugins can be leveraged to synchronize to CDNs, like Amazon Web Services (AWS). If using third-party CDNs, it’s important for the SEO to make sure the image filenames are well-optimized so the images can rank well.

7. Making pagination SEO-friendly

It is very important for SEOs and developers to work together to ensure pagination is set up correctly for SEO purposes.

If using infinite scroll or load more, use the History API to change the URL of the page when the user changes a filter or clicks on a different page. This ensures that the interface stays the same and allows for crawlable URLs for search engines, but still provides the benefits of JavaScript.

The URL to the next page should always exist on the page – this shouldn’t be an invisible click or contained only in the . For search engines to find the next URL in the series, there must be an link to that URL found in the of the DOM (and ideally in the HTML source code). This means that “Load More” buttons, which often are built using JavaScript EventListeners, must instead be written using links so that search engines are able to crawl the next URL in the series.

Too often, SEOs make recommendations without taking into consideration the specific limitations the developers face upon implementation. Similarly, developers occasionally make changes to web pages that can have a negative impact on SEO, such as removing important meta tags or accidentally noindexing important content. It is best for SEOs and developers to work in tandem to make sure that they present a united front and are able to accomplish their shared goal of improving performance for their clients.