This post started as a bit of a kiss-off to Bing. This is not to suggest that we at UpBuild have any beef with Microsoft’s eternal underdog of a search engine; while it’s unlikely to ever have the market share Google does, Bing can be a useful source of traffic, especially for specific niche markets, and it’s always best not to put all one’s eggs in Google’s basket. But since the founding of our fair company, there has been this one thing, this one feature of our standard SEO package that always required an undue sacrifice of time and effort almost exclusively for Bing’s sake, and during one of the industry discussions we had on our recent Team Day, we decided we weren’t going to take it anymore.
Backstory time. In the semantic web’s first few years, all semantic markup (a.k.a. structured data markup, nearly all of which today refers to the Schema.org vocabulary) had to be placed inline in the form of HTML attributes. This required large amounts of what I frankly feel is the worst kind of work: the kind that is at once time-consuming and tedious, and also unforgivingly delicate, such that even the slightest mistake will corrupt the entire output. It’s akin to driving in bumper-to-bumper traffic for hours on end: the task is so excruciatingly boring as to risk lulling you into a trance, but the penalty for falling into said trance would be severe. Like all SEO professionals worth our salt, I did it anyway, the thrill of those early rich snippets always having been a persuasive enough motivator for both me and my clients at the time. The cost-benefit analysis, however, left a lot to be desired.
Finally, after a year or so of prophesying from semantic SEO experts like Aaron Bradley, Google officially began to support the considerably simpler and cleaner JSON-LD format for structured data in July 2015. In another year’s time they had declared it their preferred format, and strongly echoed the sentiments of all those familiar with the unpleasantness of inline implementation when they explained their reasoning:
JSON-LD is so nice, they had to recommend it twice.
So, using the JSON-LD format:
- allows you to convey all your semantic data points in a single, solid code block added to therather than having to tie each one to an individual on-page HTML element,
- protects you from the possibility of your code breaking upon future page changes done by dev/design teams who have no idea what those itemprop attributes are even for, and
TL;DR, it’s just easier along every possible axis to do it this way. This shift occurred right around the time that UpBuild was founded, so you can imagine how grateful the alpha team was to learn, just as we were starting to draw up templates for deliverables and bundle our services, that Google had gotten with the program.
You know who hasn’t gotten with the program? Bing.
Bing made no comment of any kind to match Google’s, and all evidence continued to prove that it was still inline or nothing, ride or die over there (and that’s just in the cases where they showed a rich snippet at all, which they absolutely did less often than Google did, by the way).
Because we insisted from the founding of the company on doing things the best possible way, and because we figured it was only a matter of time before they came around, we somewhat grudgingly agreed that we would serve both JSON-LD and traditional inline markup side-by-side in our semantic SEO packages, and advise clients to deploy both at once. And so we did. And as the months turned into years, no support for JSON-LD ever materialized in Redmond, nor did any comment about why they were holding out.
What brought the matter into sharp relief for me, compelling me to bring it to Team Day as a point of discussion in the first place, was an experience I had in August. I was writing my first new semantic SEO strategy document in a while, for a very complicated page, and noticed that the JSON-LD portion of the work had taken, at most, 15% of my total time investment, while the inline portion gobbled up the other 85%. That meant that 85% of the work I put into the deliverable was to satisfy a search engine with (as of the most recent estimates) a 7.3% market share. So on our Team Day, we decided that the absurdity of this inequality had become indefensible and we needed to make a policy change. In true UpBuild style, we put it to a vote around our cabin’s long dining room table: “do we hereby stop composing inline markup for our semantic SEO strategy documents?” It was a unanimous yea.
So now that I’ve laid out the story with care, and hopefully made a compelling argument as to why we were ready to stop caring about Bing in this instance, I think you guys are ready to learn that Bing supports JSON-LD now.
I started doing research for this blog post last week and wanted to begin by comparing a page of recipe rich snippets for a particular query on Google vs. for the same query on Bing (“chocolate soufflé recipe” because I thought I might level up my autumnal dessert game while I was at it). So I took the URLs of the five rich snippets that Bing served me above the fold, plugged each one into Google’s Structured Data Testing Tool, and discovered that of the five pages’ snippets, three — including the fancy card up top — were constructed wholesale out of JSON-LD. Only two contained any inline markup at all. So at some point since Aaron Bradley’s most recent open letter of late March linked above — in the dead of night, apparently — Bing wised up.
Bing search results for “chocolate soufflé recipe”, showing the markup implementation method for each rich snippet served.
Take it from Martha Stewart. JSON-LD? It’s a good thing.
So now this post can end, because in the time since I started writing it, the number of even vaguely justifiable reasons to keep composing inline semantic markup fell from a weak 1 to a strong 0. We were already prepared to be done with inline markup, and this post had been intended as our line in the sand. And now the sand is gone.
Stay tuned for some future posts unpacking the virtues of JSON-LD described earlier, particularly as they pertain to UpBuild’s preferred ways of doing things (spoiler: we dynamically inject it using GTM as often as humanly possible).
Edit: since writing this, I had a rewarding conversation on Twitter with none other than Aaron Bradley, the authority whom I quoted and linked to most throughout this post. He inspired me to mention something that I frankly should have in the first place, which is that Recipes have long been at the vanguard of semantic markup, often not only being the first kind of entity on which new developments show, but also a playground for testing different search features that don’t always last (remember when Google let you refine your Recipe searches according to attributes and get a filtered SERP? They don’t do that anymore). So it’s very much worth explicitly stating that I chose to use Recipe as my testing entity for this reason, and that Bing doesn’t show the same kind of robust support for JSON-LD on other entity types. Aaron said he couldn’t find an example of a product entity in JSON-LD getting a rich snippet on Bing, for instance. So while we at UpBuild feel justified in ceasing the inline work at this point, it’s important to note that Bing does not yet show the same range or richness of support for JSON-LD as does Google. All I’ve managed to prove is that they’ve started down that road, and while we can probably feel safe betting that their support will deepen and expand, it’s far from guaranteed.