Ranking for Your Own Agency Name: How We Rebuilt the Brand SERP for jaspero.co

Why an agency can fail to rank for its own name

An agency can fail to rank for its own name when search engines cannot confidently connect the brand string to a single organization. Ambiguous names, thin homepage entity signals, missing structured data, and stronger unrelated entities sharing the same word all push the official site down the brand SERP.

"Jaspero" is not a word we invented for ourselves alone. There are unrelated software libraries, product names, and personal handles using the same string across GitHub, package registries, and directory sites. When someone searches the term, the engine has to decide which Jaspero they mean. If our own pages do not say clearly and repeatedly that Jaspero is a software development company based in Croatia, with these people, these clients, and these public code repositories, the engine has little reason to prefer us.

The symptom we saw in Search Console was blunt: the query "jaspero" showed an average position near the bottom of page one with no clicks. Impressions existed, so the query was being served, but our result was not the one people were looking at or clicking. That is a brand SERP problem, not a content problem. No amount of new technical blog posts about SvelteKit or Firestore fixes it, because those posts are about other topics entirely.

What we fixed first: making the homepage an unambiguous entity page

The first fix was turning the homepage into an explicit entity definition rather than a marketing page that happened to include the company name. That means a clear "Jaspero is a software development agency" sentence in real text, consistent legal name usage, location, founding context, and services described in plain language a parser can read.

Marketing homepages tend to lead with a value proposition like "We build software that scales" and never state, in a single crawlable sentence, what the organization actually is. That is fine for humans who already know where they landed. It is useless for an engine trying to resolve an ambiguous string. We rewrote the top of the page so the brand name appears next to its category and location in normal prose, and we made sure the title tag and H1 both carry the brand name rather than only a tagline.

We also stopped hiding facts inside images and animations. Client names, technology focus, and the team page all needed to exist as text in the initial HTML response. Since jaspero.co is a SvelteKit site, we verified the server-rendered output directly rather than trusting what the browser showed after hydration, because those two can differ in ways that quietly cost you entity signals.

• • A plain-text definition sentence: brand name, entity type, location, primary services
• • Brand name in the title tag, H1, and og:site_name, not just the logo file
• • Server-rendered HTML containing team, client, and service facts (verified with view-source, not devtools)
• • A single canonical domain with consistent trailing-slash and www handling so signals do not split

Organization and sameAs schema: the markup that connects the profiles

Organization schema with a sameAs array is the most direct way to tell search engines which external profiles belong to your brand. It links the website to your GitHub organization, LinkedIn page, Crunchbase entry, and any other verified profile, consolidating scattered mentions into one entity instead of several weak ones.

Our Organization block declares name, alternateName, url, logo, description, foundingDate, address, and contactPoint, plus a sameAs array pointing at the profiles we actually control. The rule we follow is that sameAs should only contain URLs where the brand is unambiguously us and where that profile links back to jaspero.co. A one-way claim to a profile you do not control is noise at best. Reciprocal links between the site and each profile are what make the association credible.

We layered a WebSite entity for the domain and ProfilePage or Person markup for team members where it made sense. We deliberately avoided over-marking. Sprinkling schema onto every component is a common instinct and it mostly generates validation warnings. What matters is one clean, correct Organization node emitted site-wide, ideally from a shared layout so it cannot drift between pages.

• • Organization: name, alternateName, url, logo, description, address, contactPoint
• • sameAs: GitHub organization, LinkedIn company page, and other profiles that link back to the site
• • WebSite entity on the domain, emitted once from the root layout
• • Validation through Rich Results Test and Schema.org validator before shipping, then re-crawl in Search Console

Using GitHub, case studies, and open source as corroborating evidence

Structured data states a claim. Corroborating evidence outside your own domain is what makes search engines believe it. Our strongest assets were an active GitHub organization with public repositories and client case studies naming real companies, so we wired both into the entity graph deliberately rather than leaving them isolated.

The github.com/Jaspero organization hosts real, maintained repositories: the source of agrimatco.hr as a full SvelteKit and Firebase example, sites and CMS work for the Human Glycome Project, the International Glycoconjugate Organization, Genos, and Bioinspekt. Each of those repositories now points back at jaspero.co, and the site's open source section links out to each repository. That two-way relationship is a much stronger disambiguation signal than a schema property alone, because the repositories carry independent activity, contributors, and inbound links.

We did the same with case studies. Pages for GlycanAge, Plodovi, Four, MOVE & MEET, and Buqtivity each name the client, the industry, and the systems we built. They give the entity a factual footprint: which companies Jaspero works with, in which sectors, over what period. Internally we interlinked those case studies with the relevant engineering posts, so a post about Firestore cost control links to the platform where those decisions were made, and vice versa. The result is a dense internal graph where every path reinforces the same entity rather than a set of orphaned pages.

Disambiguating from unrelated entities that share the name

Disambiguation means giving search engines enough distinguishing context that your brand is not merged with, or outranked by, an unrelated entity sharing the string. The practical tactics are consistent co-occurrence of your name with unique attributes, alternateName markup, and building authority around brand-plus-modifier queries first.

Almost every mention of us on our own properties now co-occurs with terms that no other Jaspero shares: our location, our founders, our clients, our stack. Engines resolve entities partly through co-occurrence, so if "Jaspero" reliably appears near "software development agency", "Croatia", "SvelteKit", and specific client names, the cluster becomes distinct from a library or a username that never appears in that context.

We also stopped chasing the bare head term as the only success metric. Brand-plus-modifier queries such as "jaspero agency", "jaspero software", and "jaspero case studies" are easier to win and they train the association. Once those consistently resolve to us, the bare term tends to follow. It is the same principle as long-tail content strategy applied to your own name, and it is measurable weekly in Search Console rather than requiring a leap of faith.

How to measure whether brand SERP work is actually working

Measure brand SERP health with three signals: average position and click-through rate for the exact brand query in Search Console, the share of the first page occupied by properties you control, and whether your entity resolves correctly in AI answer engines when asked who or what the brand is.

Position alone is misleading. A brand query at position three with zero clicks means the result is being served but not chosen, which usually points at a weak title, a missing sitelink set, or a snippet that does not confirm the searcher's intent. We track clicks and CTR for the exact-match brand query and treat any impression-heavy, click-poor pattern as a snippet problem rather than a ranking problem.

The second signal is real estate. On a healthy brand SERP, the first page is mostly yours: homepage with sitelinks, GitHub organization, LinkedIn, case study pages, sometimes a blog post. The third signal is newer and increasingly relevant. Ask ChatGPT, Perplexity, or Google's AI overview what Jaspero is, and see whether the answer describes a software agency with the right clients and stack or something unrelated. That answer is generated from the same entity signals, so it functions as a fast qualitative check on whether the structured data and corroborating links are landing.

• • Exact-match brand query: impressions, clicks, CTR, average position, tracked weekly
• • Page-one ownership: count of results pointing at properties you control
• • Sitelinks present for the homepage result, which usually indicates entity confidence
• • Entity resolution check in AI answer engines, repeated monthly

Several of the corroborating signals described here are just real work made public, like the public source of agrimatco.hr, a full SvelteKit and Firebase site we maintain in the open.