In July 2019, Google suffered a severe outage across several of its services. Google’s servers are responsible for hosting and running some of the most-used services on the internet today. That means when Google’s servers go down, and the company suffers even a small outage, it will inevitably affect a large number of users. While Google described the 2019 disruption as a small one, the number of users affected was significant. It may have only been a tiny part of Google’s network, but millions felt the impact.
Thankfully, these kinds of outages on Google’s network are rare, but they do happen. In fact, within the last week (11th August 2020), Google suffered another severe bug that caused issues with its search indexing. The new bug in Google’s systems caused users to see very odd results for their searches.
You might wonder how a business with the resources and reach of Google could fall victim to something as basic as a software bug, especially given that they rely on those services being accessible to function and make money. However, bugs are an unavoidable part of software development. Google is just as susceptible to the effects as anyone else.
What Are Bugs?
Let’s begin by considering the nature of software bugs generally. It doesn’t matter how good at programming the developers are, or how vigilant they are when they are writing their code; it is always possible for bugs to appear.
A software bug can represent an error in the underlying code, but this isn’t always the case. Sometimes, bugs arise because, despite the code being perfect, there are hardware conflicts. Other bugs are the result of a bug in the compiler that converts source code into machine code.
When a bug is present in a piece of software, the software will do something that isn’t supposed to do. This includes instances where the software allows to user to perform actions that should be forbidden. For example, if you write a piece of software that asks the user what their name is but lets them fill in the field with numbers instead of letters, this would be considered a bug. It is up to the developer to make sure that text fields can only receive text.
Where Do Bugs Come From?
In some cases, good old-fashioned human error leads to bugs in the code. An oversight on the part of the developer can mean that their code is doing something that it isn’t supposed to, or it allows the user to behave in a way that they shouldn’t.
But not all bugs are the result of a simple oversight. Google’s ecosystem is a complex one. The many different systems and services that Google operates are continually working in tandem and exchanging data with one another. There is, accordingly, a vast number of potential points of failure in Google’s services.
Bug testing is a routine part of the software development process; no serious software developer releases software without first checking it for bugs. Checking for bugs means auditing the source code to identify any glaring errors, and also executing the code and running the software to ensure that it performs appropriately in real-world conditions.
As well as using the software as intended, bug testers will also try to break the software to some extent. For example, wherever the software asks the user to input a number, bug testers will deliberately give it text to see how it responds.
Caffeine is the indexing system that Google uses to catalog and organize websites. There are several essential things that caffeine does, and if any part of the process goes wrong, it will cause effects downstream. In the simplest terms, Caffeine fetches data about websites and then processes and organizes that data. As part of this process, it extracts relevant data and sets it aside to be used by other Google services.
Google first unveiled Caffeine in 2010, touting it as an indexing system that was future proof and could scale with Google’s needs. The August 11th incident marks the first significant Caffeine issue that Google has made public.
Search Results Quality
While the glitch was active, Google’s search results deteriorated sharply in quality. Many of the results that users were seeing were utterly useless to them. Worse still, numerous small businesses around the world who were dependent upon their online sales to survive suddenly found themselves hidden from view and relegated to a much lower position in SERPs. One French business noted that they lost six years’ worth of SEO work in an instant and were seriously considering that they might lose their business.
The impact was felt around the world with users from Asia, the United States, and Europe all reporting issues. There was, completely understandable, full-blown panic from many businesses and websites who suddenly found themselves going from page one of Google’s search results to page six or seven. As anyone with SEO experience will tell you, if you aren’t on the first couple of pages, then you might as well not be there at all.
What Was The Cause?
What exactly caused this glitch? That is the big question. Given the scale of the glitch, the number of users affected, and the severe implications of the glitch for both impacted businesses and Google’s reputation, you would think that identifying the cause would be a top priority. However, all we have been able to discern since the glitch struck is that Caffeine was most likely the culprit.
Sometimes, especially when you are dealing with a complex system like Google’s search engine, it isn’t possible to pinpoint precisely why a glitch occurred. It is safe to assume that Google has some idea of what went wrong as they were able to fix the issue. However, they are yet to reveal any more details about its cause to the public.
It doesn’t matter how much money or what resources a software developer has, bugs will always happen. For a global business like Google, even a minor glitch can throw a spanner in the works. With so many different systems all working together, it only takes one small problem to break everything.