Popular WordPress plugin Yoast is releasing an update which offers defragmented implementation of Schema.org markup. Sounds complex? Not worry, we'll define the term for your understanding.
What is Defragmentation?
Here is how Wikipedia puts it: "In the maintenance of file systems, defragmentation is a process that reduces the degree of fragmentation. It does this by physically organizing the contents of the mass storage device used to store files into the smallest number of contiguous regions (fragments). It also attempts to create larger regions of free space using compaction to impede the return of fragmentation. Some defragmentation utilities try to keep smaller files within a single directory together, as they are often accessed in sequence.
Defragmentation is advantageous and relevant to file systems on electromechanical disk drives. The movement of the hard drive's read/write heads over different areas of the disk when accessing fragmented files is slower, compared to accessing the entire contents of a non-fragmented file sequentially without moving the read/write heads to seek other fragments."
Read more recent news stories:
New Google Algorithm May Update Page Ranking
Google+ is Shuting Down in April 2019
WordPress 5.0 Comes with Gutenberg Update
What makes this a first-of-its-kind update is that it cleans up the “fragmented mess” created by most Schema implementations
Even the best Schema implementations are not done very well, the company says, as they often provide no context to search engines.
For example, if a page has eight pieces of Schema markup it’s often unclear to search engines how they’re related to each other.
It’s clean, but those are still eight individual items and search engines need will need to figure out how they’re related to each other.
In addition, it’s also not clear to search engines what the main entity is on the page.
Yoast explains how the latest update to its plugin weaves everything together:
“In our implementation, which we’re releasing today, all of the pieces “stitch together”: we form them into a nested structure. Without this nesting, a search engine doesn’t know how all these pieces relate to each other, and what the most important piece on a page is. Our implementation also clearly and explicitly defines the “main thing” on that page. This removes all of the guesswork and adds a lot of context for search engines.”
You can see the difference for yourself by running one of Yoast’s example pages through Google’s structured data testing tool.
You can see that the main entity of the page is an article. The article is part of a webpage, which is part of a website.
Scrolling further down you’ll see more entities which Google detects as being related to the article, such as images, author, publisher, and more.
What does this mean for SEOs and site owners?
Implementation of Schema markup with Yoast’s plugin can result in:
- Correct info in Google Knowledge Panels.
- Full support for Rich Article Pins on Pinterest.
- Showing up in a News listing or carousel (when combined with the News SEO plugin).
- Higher chance of product snippets in Google Search results (when combined with the WooCommerce SEO plugin).
- Higher chance of good local listing snippets (with the Local SEO plugin).
Yoast SEO 11.0 with Schema.org implementation is available now by upgrading the plugin. And these new features are all available in the free version.
What is Schema Markup & Why It’s Important for SEO
What is Schema Markup?
Schema markup, found at Schema.org, is a form of microdata. Once added to a webpage, schema markup creates an enhanced description (commonly known as a rich snippet), which appears in search results.
Top search engines – including Google, Yahoo, Bing, and Yandex – first started collaborating to create Schema.org, back in 2011.
Schema markup is especially important in the age of Hummingbird and RankBrain. How a search engine interprets the context of a query will determine the quality of a search result. Schema can provide context to an otherwise ambiguous webpage.
Via Schema.org:
“Most webmasters are familiar with HTML tags on their pages. Usually, HTML tags tell the browser how to display the information included in the tag. For example, <h1>Avatar</h1> tells the browser to display the text string “Avatar” in a heading 1 format. However, the HTML tag doesn’t give any information about what that text string means—”Avatar” could refer to the hugely successful 3D movie, or it could refer to a type of profile picture—and this can make it more difficult for search engines to intelligently display relevant content to a user.”
Does Schema Improve Your Search Rankings?
There is no evidence that microdata has a direct affect on organic search rankings.
Nonetheless, rich snippets do make your webpages appear more prominently in SERPs. This improved visibility has been shown to improve click-through rates.
According to a study by acmque, less than one-third of Google’s search results include a rich snippet with Schema.org markup. This exposes a huge opportunity for the rest. Very few things in SEO, today, can move the dial quickly. This can.
What Is Schema Used For?
- Businesses and organizations
- Events
- People
- Products
- Recipes
- Reviews
- Videos
Above are some of the most popular uses of schema. However, there’s a good chance that if you have any sort of data on your website, it’s going to have an associated itemscope, itemtype and itemprop
Adding Schema to Your Webpages
Using Microdata
Microdata is a set of tags that aims to make annotating HTML elements with machine-readable tags much easier. Microdata is a great place for beginners to start because it’s so easy to use.
However, the one downside to using microdata is that you have to mark every individual item within the body of your webpage. As you can imagine, this can quickly get messy.
Before you begin to add schema to your webpages, you need to figure out the ‘item type’ of the content on your webpage.
For example, does your web content focus on food? Music? Tech?
Once you’ve figured out the item type, you can now determine how you can tag it up.
Let’s look at an example. Let’s say that you own a store that sells high-quality routers. If you were to look at the source code of your homepage you would likely see something akin to this:
<div>
<h1>TechHaven</h1>
<h2>The best routers you’ll find online!</h2>
<p>Address:</p>
<p>459 Humpback Road</p>
<p>Rialto, Ca</p>
<p>Tel: 909 574 3903</p>
<p><a href=”http://www.techhaven.com/menu”>Click here to view our best routers!</a></p>
<p>We’re open: </p>
<p>Mon-Sat 8am – 10:30pm</p>
<p>Sun: 2pm – 8pm</p>
</div>Once you dive into the code, you’ll want to find the portion of your webpage that talks about what your business has to offer. In this example, that data can be found between the two <div> tags.
Now, at the top you can add in:
<div itemscope>
By adding this tag, we’re stating that the HTML code contained between the <div> blocks are identifying a specific item.
Next, we have to identify what that item is by using the ‘itemtype’ attribute to identify the type of item our webpage is about (tech).
<div itemscope itemtype=”http://schema.org/tech”>
An item type comes in the form of a URL (such as http://schema.org/tech). Let’s say, for example, that your site revolved around beauty products instead of technology. Your item type URL might look like this:
http://schema.org/beauty.
To make things easier you can browse a list of item types here, plus you can view extensions to identify the specific entity that you’re looking for. Keep in mind that this list is not all encompassing, so there is a possibility that you won’t find the item type for your specific niche.
Tracking back to the tech page, you want to tag the part of the webpage that contains the name of the business. You can do this between the <h1> tags.
Now, we’ll be using the ‘itemprop’ tag, which labels the properties of an item:
<h1 itemprop=”name”>Tech Haven</h1>
You can apply these tags to the rest of the page now. When using tags to identify item properties, it’s not necessary to tag the entire line, just the one portion the property is making reference to.
For example, if you have a line that says Address: 1234 w sunshine blvd, then you only need to apply the tags around the address itself and nothing else.
<h2 itemprop=”description”>The best routers you’ll find online!</h2>
<p>Address:</p>
<span itemprop=”address” itemscope itemtype=”http://schema.org/PostalAddress”>
<p itemprop=”streetAddress”>459 Humpback Road </p>
<p itemprop=”addressLocality”>Rialto, Ca</p></span>
<p>Tel: <span itemprop=”telephone”>909 574 3903</span></p>
<p><a itemprop=”menu” href=”http:// http://www.techhaven.com/menu “>Click here to view our tasty range of dishes!</a></p>
<p>We’re open:</p>
<p itemprop=”openingHours”>Mon-Sat 8am – 10:30pm</p>
<p itemprop=”openingHours”>Sun: 2pm – 8pm</p>
</div>This code may look complicated, but schema.org provides examples on how to use the different item types, so you can actually see what the code is supposed to do. Don’t worry, you won’t be left out in the cold trying to figure this out on your own!
If you’re still feeling a little intimidated by the code, Google’s Structured Data Markup Helper makes it super easy to tag your webpages.
To use this amazing tool, just select your item type, paste in the URL of the target page or the content you want to target, and then highlight the different elements so that you can tag them.
Using RDFa
RDFa is an acronym for Resource Description Framework in Attributes. Essentially, RDFa is an extension to HTML5 and it was designed to aid users in marking up structured data.
RDFa is considered to be a W3C recommendation, meaning that it is a web standard, and it can be used to chain structured data vocabularies together. This is especially useful if you want to add structured data that stretches beyond the limits of Schema.org.
You can breathe a sigh of relief. RDFa isn’t much different from Microdata.
Similar to microdata, RDFa tags incorporate with the preexisting HTML code in the body of your webpage. For the sake of familiarity, we’ll look at the tech website once again as an example.
The HTML for your tech site would likely look like this before it was modified:
<div>
<h1>Tech Haven</h1>
<h2>The best routers online!</h2>
<p>Address:</p>
<p>459 Humpback Road </p>
<p>Rialto, Ca</p>
<p>Tel: 909 574 3903</p>
<p><a href=”http://www.techhaven.com/menu”>Click here to view our best routers!</a></p>
<p>We’re open:</p>
<p>Mon-Sat 8:00am – 10:30pm</p>
<p>Sun: 2pm – 8pm</p>
</div>To begin, you want to ensure that the vocabulary that you’re using is Schema.org and that the webpage in question is making reference to a technology page.
For this example, you can search for “technology” on Schema.org to learn how to tag different elements. Typically, you’ll find examples near the bottom of the page that will show you how to use them in practice.
Simply click on the RDFa tab to view specific RDFa examples.
Next, you need to use the vocab tag combined with the URL http://schema.org to identify the vocabulary for the markup. To identify the page type, use the typeof tag. Unlike microdata, which uses a URL to identify types, RDFa uses one or more words to classify types.
<div vocab=”http://schema.org/” typeof=”technology”>
If you wish to identify a property further than you should use the typeof attribute.
For example, if you wish to further expand upon an address property you can use “PostalAddress” like so:
<div property=”address” typeof=”PostalAddress”>
Comparing microdata and RDFa side by side, the typeof attribute is the equivalent of the itemtype attribute found in Microdata. Furthermore, the property attribute would be the equivalent to the itemprop attribute.
For further explanation, you can visit Schema.org to check lists and view examples. You can find which kinds of elements are defined as properties, and which are defined as types.
Going back to our earlier example, the tech page would look like this after it has been appropriately tagged:
<h2 property=”description”>The best routers on the internet!</h2>
<p>Address:</p>
<div property=”address” typeof=”PostalAddress”>
<p property=”streetAddress”>459 Humpback Road</p>
<p property=”addressLocality”>Rialto, Ca</p>
</div>
<p>Tel: <span property=”telephone”>909 574 3903</span></p>
<p><a property=”menu” href=”http://www.techhaven/menu”>Click here to view our best routers!</a></p>
<p>We’re open:</p>
<p property=”openingHours”>Mon-Sat 8am – 10:30pm</p>
<p property=”openingHours”>Sun: 2pm – 8pm</p>
</div>To aid you, every page on Schema.org provides examples on how to properly apply tags. Of course, you can also fall back on Google’s Structured Data Testing Tool.
What Are Google’s Guidelines on Schema Structured Data?
Let’s shift gears just a little bit here.
Instead of providing a word-for-word assessment of Google’s guidelines for structured data, I wanted to provide my own interpretation of their guidelines based on my own previous experience and give you some overall tips you can use to avoid any issues that may arise with violating Google’s guidelines in the future.
As we are all well aware, Google has plenty of guidelines to restrict spammy schema markup and make sure that the spam does not show up in the SERPs.
It should be noted that schema structured data should not be spammy in any way, and should always accurately reflect what the page is about.
If you use spammy schema structured data en masse, then you can expect to eventually be penalized by Google at some point for spammy use of this data.
Google’s main goal is for its search results to be spam-free. Does this work in the real world? Not always.
And, as we all know, it’s not as simple as simply policing the web for spam. That would be impossible with millions of queries being searched per day.
To avoid the situation where your markup is considered spammy, Google recommends that you make sure it meets their own structured data guidelines and that you don’t brute-force pound their results with spam.
One of the best tips I can give you is: to make sure that your schema markup meets Google’s guidelines, always ensure that your markup aligns with the user intent of the page.
This means that a close match of user intent should be taking place with all implementation of Schema markup for that page.
Don’t markup a page intended for a sporting event with markup that is intended for a restaurant. While that is a more “out there” example, it can happen. I just wanted to provide a clear example so as to clear up any confusion that may arise.
Google stresses not to create any schema markup that makes content invisible to any user who may be consuming that content. It should be the same as the markup being used for that purpose.
You should also not be using markup that is either “irrelevant or misleading,” per their guidelines. If your local page serves attorneys, don’t use schema markup to mark up data intended for doctors, and vice versa.
Google also specifies in their guidelines that your schema markup should be complete in order to fall within their parameters for inclusion. This means that if the markup calls for an image, or other specific pieces of information, do not neglect to include it.
What’s the Difference Between Structured Data, Rich Snippets, and Schema?
One of the main reasons more websites are not effectively marked up is due to confusion over what code to add and why.
Adding to this confusion is the phrases associated to this topic – and I want to clarify some of this for you.
Structure Data
Structured data is the term people use, often interchangeably, to describe code added to a website or used in parsing that code, which follow existing rules to support information understanding.
Schema, rich snippets, microformats, RDFa, and Twitter cards are all examples of structured data.
The easiest way to remember this is that structured data has been marked up so that it can be understood more effectively, unstructured data has not.
Google, for example, identifies and reads structured data so that it can display rich snippets in its search results.
Rich Snippets
Introduced by Google back in 2009, rich snippets refer to search engines displaying extra information about a website’s content in search engine results pages (SERPs).
Using an example of typing in my company name “Vertical Leap”, we can see how rich snippets can show review stars, an aggregate rating value and tie into the ‘local box results’ (among other areas):
Schema
Schema is the agreed vocabulary that websites use to make it easy and consistent to create code to mark up their pages so that they can be understood better by search engines.
There are lots of schemas and you can see the full schema list here.
Website Components to Markup Today
Depending on your industry, your offering, unique value proposition, and business model, the most important elements of your website to markup will change.
The following are some of the most frequently used – and potentially valuable – markup types spanning a majority of industries.
- Product: Whether a physical product like a CD or, an end product delivered by a professional, for example, a haircut, this is used by over one million domains. This is also a rich snippet-supported markup so it can offer search specific gains.
- Review: Personally, I believe the review schema code has the biggest potential impact for generating more traffic from existing visibility. This code can support star rating in search results, convey trust onsite and offsite and provide many other gains.
- Event: Only used by about 1/10 of the sites using product markup (lower estimates at 100,000 for usage), this is a massively under-utilized opportunity and can provide greater user value at preclick level including dates, times, locations, and more within your search result.
- Article: Google can use article markup to promote them in their features like “In the news” as well as important user elements of the search results like content carousels. This type of markup can be key for search vertical specific gains, brand and reach value, and much more.
- Video: With the growth of mixed content types displayed in the majority of competitive page one Google SERPs, the relationship between Google and YouTube, and the mass appeal of video for content digesting, this is a must for any chance of gaining video visibility online.
The above really is a tip of the iceberg. I would strongly suggest delving into other areas like breadcrumb markup, person, and organization.
Google’s Structured Data Testing Tool, or Other Testing Tool
Before ever adding code to your site, you want to make sure that your code validates.
The best way to do this is by testing it in Google’s Structured Data testing tool, which we will get to in a moment.
Setting up Your Code Structure
With schema markup, it is necessary to first plan out your structure so that it complies with Google’s guidelines. Then, these steps:
- Look up your needed schema data type on the schema.org website.
- Get the local information for the page you wish to include schema markup on and gather up all the code you wish to use.
- Code your schema entities.
- Test your code via Google’s Structured Data Testing tool.
- Crawl and test your schema markup in Google’s Search Console.
- Monitor results of this implementation on an ongoing basis with entity results reporting.
Troubleshooting Your Markup
If you have created markup and you have not been able to successfully validate this markup within Google Search Console, there can be several reasons why.
The Syntax of Your Code Has Issues
Make sure that you haven’t let an errant colon or semicolon slip into your coding.
Also, errant quotes that are not quotes, apostrophes, and brackets that should not be where you inserted them should be taken care of.
Issues Stemming From the Use of Microsoft Programs
Guess what?
Microsoft programs (I am looking at you, MS Word and Excel) can cause issues when you copy and paste your code.
For example, quotes are not rendered properly in other programs when they are pasted from Word or Excel.
Just to be safe, be sure that you use something like Notepad, Notepad++, or Dreamweaver when you are copying and pasting the code.
Otherwise, straight typing your code into Google’s Structured Data testing tool will be necessary.
This comes to one more point. If you are testing your code in Google’s Structured Data Testing tool, you are copying and pasting from other programs, and you know your code is right, but it is throwing errors, try typing it in the tool line by line.
Your code may be just right, but the quotes from other programs are what are throwing those errors.
Proper Itemtype / Schema Vocabulary
If all other issues are correct, and your schema markup still presents errors, you may not have included all requirements for the Itemtype as presented in the schema vocabulary.
It is a good idea to do a thorough analysis of your code vs. the required item types in the schema vocabulary just to make sure that your code matches up with all requirements needed for the code to pass.
Any Violations of Google’s Guidelines or Policies
Even Google guidelines and policies violations can cause issues. Do a review of the guidelines from Google just to make sure that you haven’t violated any major (or minor) policies that are usually set forth in these guidelines.
Thursday, May 2, 2019
