Schema Gorilla Case Study · 22 August 2026
14,577 Nodes. 36,414 Relationships. Zero Findings.
What happened when we corrected the issues found in an earlier Schema Gorilla analysis, expanded our website and entity architecture, connected new external technical identity records — and then ran the entire live site again.
This was not the first time we ran Schema Gorilla against Sydney Business Web.
Our earlier whole-site analysis identified structural and entity issues that gave us something useful to do: investigate them, correct the underlying relationships and improve the way the website represented Sydney Business Web as a connected machine-readable business identity.
We corrected those issues.
But we did not then freeze the website in its corrected state. Sydney Business Web continued to change.
Since that earlier analysis we have added and revised content, expanded our structured-data architecture, strengthened business and service relationships, developed clearer AI Visibility and AI Search terminology, and improved the way people, professional credentials, services and technical systems connect across the site.
We also extended the technical identity beyond the website itself.
Schema Gorilla and AI Observatory now have public technical documentation on GitHub and versioned technical releases archived through Zenodo. Keith Rowley’s technical identity is connected through a personal GitHub profile, ORCID and LinkedIn, while Sydney Business Web has its own organisational GitHub identity.
In other words, after correcting the earlier problems, the machine-readable architecture did not become simpler. It became larger and more interconnected.
Discovery identified 274 URLs and queued all 274 for retrieval. Four sitemaps were processed, the discovery limit was not reached, and 273 pages ultimately became eligible for Schema Gorilla analysis.
Schema Gorilla then analysed all 273 eligible pages and resolved a whole-site graph containing 14,577 schema nodes, 36,414 relationships and 28 entity clusters.
The Graph Grew. The Findings Disappeared.
The comparison with our earlier recorded Schema Gorilla run is what makes this result particularly useful. The site now contains materially more structured-data nodes and relationships than it did previously.
33,896 schema relationships across the previous whole-site graph.
36,414 relationships across 273 fully analysed pages.
+2,518 relationships — roughly 7.4% growth in the size of both measures.
We corrected the problems identified in the earlier analysis, expanded the graph by roughly 7.4%, and a completely fresh Schema Gorilla ruleset 2.2 analysis returned zero findings and zero finding occurrences.
THE IMPORTANT PART IS NOT “ZERO”
Complex Schema Is Easy to Add. Keeping It Coherent Is the Engineering.
Anyone can add another JSON-LD block to a website.
The difficult part begins when a site contains thousands of structured-data nodes describing businesses, people, services, credentials, products, technical systems, identifiers and relationships across hundreds of pages.
At that point, adding more schema can easily create competing identities, inconsistent identifiers, disconnected entities or relationships that make sense locally but conflict when the website is examined as one system.
Sydney Business Web had already corrected issues found during an earlier Schema Gorilla analysis. We then continued changing the production website — adding content, expanding entity architecture and connecting new external identity and publication records.
The resulting graph was not smaller or simpler. It grew to 14,577 nodes and 36,414 relationships.
Zero findings does not mean that every conceivable schema defect has been proven impossible. It means Schema Gorilla ruleset 2.2 detected none of the whole-site identity, relationship and structural problems it is currently designed to identify.
INTERPRETING THE RESULT
What Does “Zero Findings” Actually Mean?
It is a strong result — but it needs to be described accurately.
Gorilla Found No Problems Covered by Its Current Whole-Site Rules
Schema Gorilla ruleset 2.2 completed its analysis of all 273 eligible pages and returned zero findings and zero finding occurrences.
In practical terms, none of the whole-site entity, identity, identifier, relationship or structural conflict patterns currently covered by the ruleset were detected in the fresh graph.
It Is Not a Claim That Every Possible Schema Defect Is Impossible
Schema Gorilla is not a magical certificate of universal schema perfection.
A zero-finding result means the analysis found none of the problem classes it is currently engineered to detect. New rules, new data or future changes to the website could produce different findings.
The important distinction is between claiming perfection and reporting an observed engineering result.
We are doing the latter.
FRESH PRODUCTION RUN
The Technical Record
The case study was generated from a new Discovery run and a new Schema Gorilla analysis. Previous analysis data was not reused.
Discovered and queued for retrieval
273 of 273 eligible pages completed
Collected during the Discovery process
Observed during whole-site analysis
Resolved across the analysed graph
Approximately 5 minutes 6 seconds
Raw Discovery and Schema Gorilla run records were preserved at the time of analysis, including launch responses, completion data, counts, timestamps and version information.
The Validation Blind Spot
A Valid Page Is Not the Same Thing as a Coherent Website.
This distinction is central to why Schema Gorilla exists. Page-level structured-data validation and whole-site entity analysis solve different problems.
Is the Structured Data on This Page Valid?
Conventional structured-data validators are extremely useful. We use them ourselves.
They can identify malformed JSON-LD, invalid properties, missing fields and eligibility problems for particular structured-data features.
Each page may look perfectly acceptable when inspected independently.
Do All Those Valid Pages Describe the Same Reality?
The harder question appears when hundreds of those pages are joined together.
Does the same business retain the same identity? Are people connected to the correct organisation? Do services, systems and credentials resolve consistently? Are identifiers reused correctly rather than creating competing entities?
Schema Gorilla examines that accumulated network rather than treating every page as an isolated document.
Page validators ask whether a particular document contains technically acceptable structured data. Schema Gorilla asks what happens when the structured data across the entire website is connected into one machine-readable identity graph.
In this fresh Sydney Business Web case study, Schema Gorilla analysed 36,414 relationships across 14,577 nodes.
That is why “our pages validate” is not the same claim as “our whole-site entity architecture remains coherent.”
AI Visibility & AI Search
Why Whole-Site Identity Coherence Matters Beyond Schema Validation.
Structured data is only one part of AI Visibility. But if a website is going to describe its business in machine-readable form, those descriptions should resolve into one coherent identity rather than hundreds of disconnected or competing versions of the same organisation.
Can Machines Access the Information?
Before anything else can happen, search engines and AI-related crawlers need to be able to retrieve useful public information from the website.
Crawler access, technical performance, indexability and server behaviour all matter at this stage.
Can the Business Identity Be Resolved?
Once information is available, machines still need to distinguish the business, its people, services, systems and identifiers.
Consistent entity architecture can reduce ambiguity about which facts and relationships belong to which entity.
Do the Relationships Form a Coherent Picture?
A business is not represented by one schema block. Its identity is distributed across pages, people, services, articles, credentials and external corroborating records.
The engineering challenge is making those pieces connect without contradiction.
The recent changes to Sydney Business Web illustrate this particularly well.
We did not merely add more schema properties. We connected new professional identity information, technical systems, public GitHub documentation, versioned Zenodo releases, ORCID identity data, services and content back into the wider Sydney Business Web entity architecture.
That made the graph more complex, not less.
Schema Gorilla then gave us a way to test whether that increasing complexity had introduced whole-site identity or relationship problems covered by its current ruleset.
The objective is not “more schema”. The objective is a clearer, more consistent machine-readable representation of the real business — supported by content, technical accessibility, entity relationships and corroborating evidence.
What Makes Schema Gorilla Different
The Remarkable Part Is Not That It Checks Schema. It Checks the Whole Website.
That distinction sounds simple, but it changes the engineering problem completely. Schema Gorilla does not stop after determining whether individual JSON-LD blocks are valid. It reconstructs the structured data found across the website into a connected entity graph and then examines what that combined graph says about the business.
A conventional page validator might examine those 273 pages individually.
Schema Gorilla instead asks what happens when the entities and relationships from all 273 pages are brought together.
In this case that meant analysing a network containing 14,577 nodes and 36,414 relationships.
That is a fundamentally different scale of question from: “Is this block of schema valid?”
Collect the Site
Discover the eligible pages and extract the structured-data evidence distributed across them.
Reconstruct the Graph
Resolve entities, identifiers and relationships into a whole-site network instead of isolated page fragments.
Test the Identity
Examine the combined network for the structural and identity problems covered by the current Gorilla ruleset.
“Schema Gorilla evaluates your entire website as a single, connected entity graph rather than auditing it page-by-page.”
That is a remarkably accurate description of the architectural difference. Google also identified identity fragmentation, competing identifiers and broken cross-page relationships as the kinds of problems that whole-site analysis can expose even where individual pages appear technically valid.
This is why Schema Gorilla is unusual. It is not simply another schema syntax checker. It is designed to ask whether the accumulated structured-data architecture of an entire website still describes one coherent business reality.
The Engineering Loop
The Point Is Not to Get a Score. The Point Is to Find Problems, Fix Them and Test Again.
Schema Gorilla is most useful as part of an engineering cycle. A finding is not a failure of the system. A useful finding is exactly what the system is supposed to produce when the whole-site identity graph contains a problem that needs investigation.
Build the Whole-Site Graph
Discover the website, extract its structured-data evidence and reconstruct the entities and relationships into one connected network.
→Investigate the Findings
Determine whether competing identities, identifiers, broken relationships or other detected structures reflect a genuine architectural problem.
→Repair the Underlying Architecture
Correct the real entity relationships, schema architecture or supporting content rather than merely trying to silence a diagnostic message.
→Run the Site Again
Rebuild the graph from fresh website evidence and confirm whether the repaired architecture remains coherent as the site continues to evolve.
Schema Gorilla Found Issues.
Our earlier analysis did not give us a perfect result.
It exposed structural and entity issues that we investigated and corrected. That was useful engineering information — not something to hide.
The Website Had Changed Substantially.
We had added content, entities, identifiers, relationships, technical systems and new external identity records through GitHub, Zenodo and ORCID.
The graph grew to 14,577 nodes and 36,414 relationships. A completely fresh whole-site run then returned zero findings.
The important result is not that Sydney Business Web somehow started with flawless schema.
The important result is that Schema Gorilla found problems, we corrected them, the website became substantially more complex, and the fresh analysis remained clean under the current ruleset.
We do not treat structured data as a one-off installation that is forgotten after launch. Business identities, websites, people, services and corroborating records change. The machine-readable architecture needs to be capable of changing with them — and of being tested again afterwards.
What This Means for a Business
You Do Not Need to Understand 36,414 Relationships to Have a Business Identity Problem.
The technical scale of this case study is interesting to engineers. For a business owner, the practical issue is considerably simpler: individually valid pages can still combine to describe the business inconsistently.
Identify Problems That Page Testing Can Miss
Schema Gorilla examines the accumulated structured-data architecture for the classes of cross-page identity and relationship problems covered by its current ruleset.
Determine What the Finding Actually Means
A diagnostic result still needs engineering judgement. We investigate whether a finding reflects a genuine problem in the business identity, identifiers, content or entity relationships.
Correct the Architecture and Run It Again
Where a real problem exists, the objective is to repair the underlying representation of the business — and then verify the changed website against fresh evidence.
Sydney Business Web asks clients to trust us with the machine-readable representation of their businesses.
It would be difficult to take that proposition seriously if we were unwilling to subject our own production website to exactly the same whole-site analysis.
The earlier Schema Gorilla run did find issues. We investigated them and corrected them.
We then continued adding content, identities, relationships, technical systems and external records. The site became substantially more complex — and we ran it again from fresh Discovery data.
Schema Gorilla as a Service
Whole-Site Entity Analysis Is Currently Delivered as an Engineering Service.
Schema Gorilla is currently operated by Sydney Business Web as part of a professional AI Visibility and structured-data engineering service.
We run the analysis, interpret the resulting entity graph and findings, investigate the underlying cause of genuine structural problems, and recommend or implement appropriate corrections.
The objective is not to manufacture a perfect-looking score. It is to produce a more coherent, defensible machine-readable representation of the real organisation.
That is the real result of this case study: not simply that Schema Gorilla returned zero findings, but that we used it as intended — to identify problems, correct them, continue developing a substantially larger entity graph, and then independently test the changed architecture again.
Schema Gorilla Case Study FAQ
Frequently Asked Questions
The most important questions are not about how much schema a website contains, but what happens when that structured data is treated as one connected system.
What is Schema Gorilla?
Schema Gorilla is a whole-site structured-data and entity-graph analysis system developed by Sydney Business Web. It reconstructs structured data across a website into a connected network so that cross-page identity, identifier and relationship problems can be examined at site scale.
How is Schema Gorilla different from a standard schema validator?
Standard validators are primarily concerned with the structured data on an individual page or code block. Schema Gorilla examines what happens when structured data from the whole website is combined into one entity graph. The two approaches are complementary, not substitutes for one another.
What did this Schema Gorilla case study analyse?
A fresh Discovery run identified 274 URLs on Sydney Business Web. Schema Gorilla subsequently analysed all 273 eligible pages, resolving 14,577 schema nodes, 36,414 relationships, 93 schema signatures and 28 entity clusters.
What does “zero findings” mean?
It means Schema Gorilla ruleset 2.2 detected none of the whole-site structural, entity, identity or relationship problems that the current ruleset is designed to identify. It does not mean that every conceivable schema defect has been proven impossible.
Did Sydney Business Web always receive zero findings?
No. An earlier Schema Gorilla analysis identified issues that were investigated and corrected. Sydney Business Web then continued adding content, structured data, entities and external identity records. The later fresh run analysed a larger graph and returned zero findings under ruleset 2.2.
Does coherent schema guarantee visibility in AI Search?
No. Structured data and entity coherence are only parts of AI Visibility. Retrieval access, useful content, business evidence, external corroboration and other signals also matter. Schema Gorilla is designed to assess the machine-readable identity architecture — not to promise rankings, citations or recommendations from an AI system.
Schema Gorilla is currently delivered as an engineering service by Sydney Business Web. The analysis is interpreted in context, and genuine structural problems can then be investigated and corrected rather than merely reported as a score.
Technical Sources & References
References
This case study combines live production evidence from the Sydney Business Web website with the public technical documentation and persistent publication records for Schema Gorilla.
Sydney Business Web product and methodology overview.
sydneybusinessweb.com.au/schema-gorilla-business-identity-analysis-for-ai/GitHub repository documenting the architecture, methodology and technical scope.
github.com/Sydney-Business-Web/schema-gorillaPersistent archived technical release on Zenodo.
DOI 10.5281/zenodo.22040501Page-level structured-data validation resource used as a complementary validation tool.
validator.schema.orgGoogle's testing tool for supported structured-data rich-result eligibility and implementation issues.
search.google.com/test/rich-resultsPersistent professional and technical-author identity record.
ORCID 0009-0004-9341-7979During preparation of this case study, a Google AI response independently described Schema Gorilla as evaluating an entire website as a single connected entity graph rather than auditing it page-by-page. The response is quoted in this article as an observed search result rather than as technical validation of the product.
Whole-Site Business Identity Analysis
Would Your Website Still Make Sense If Every Page Were Joined Together?
Individual schema blocks can validate while the wider website still presents fragmented, competing or disconnected machine-readable identities. Schema Gorilla is designed to examine that whole-site problem.
Sydney Business Web currently delivers Schema Gorilla as an engineering service: we run the analysis, interpret the findings, investigate genuine structural problems and help correct the underlying entity architecture where required.
Schema Gorilla does not guarantee search rankings, AI citations or recommendations. It provides engineering analysis of the structured-data and entity relationships that contribute to a coherent machine-readable representation of a business.
