Technical Writing Sample

Three short samples, one product, and three different writing contexts. Google Search Console runs through all of them.

The first is a how-to guide for someone troubleshooting their own site. The second is API documentation for a developer working directly with Search Console's data. The third rewrites interface messages that tell you what happened without telling you what to actually do next.

I picked one product on purpose. It lets these samples show how I approach technical writing from different angles. One explains a task, one documents a system, and one turns confusing information into something you can actually act on. All three are based on things I genuinely ran into while using Search Console myself, not made-up scenarios.

Sample 1: How-to guide

How to Check Why a Page Isn't Indexed in Google Search Console

This guide is for website owners and content creators managing their own site indexing. It walks through the troubleshooting process in Google Search Console step by step.

You published a page three days ago. Search Console still says Google hasn't indexed it. You click Request Indexing again. Nothing changes.

That doesn't necessarily mean something is broken.

Before you click it a fourth time, check what Search Console is actually telling you. Not indexed isn't one diagnosis. It's the result of several different situations, and each one needs a different response.

Open URL Inspection

In Search Console's left sidebar, click URL Inspection. This tool lets you inspect a specific URL and see how Google last crawled and indexed it.

Paste the exact URL you're checking and press Enter.

What you see first describes Google's indexed version of the page. If you made a change recently, Search Console may still be showing information from the previous crawl.

Read the status correctly

The result shows a status, and which one you get matters.

URL is on Google means the page is indexed and eligible to appear in search. That doesn't mean it'll rank for the query you're targeting, or show up anywhere prominent. If what you're actually worried about is visibility, not indexing, that's a different problem than this guide is solving.

URL is not on Google means the page isn't indexed yet, and that's where you need to dig further.

Don't stop here, though. The next part tells you exactly which situation you're in.

Check the specific reason

Look at the Page indexing information in URL Inspection. You may see one of these statuses.

URL is unknown to Google. Google doesn't currently have information about this URL. This is different from a page Google knows about but hasn't gotten to yet. Check that the URL is included in your sitemap and linked from somewhere else on your site, then request indexing.

Discovered, currently not indexed. Google knows the URL exists but hasn't crawled it yet. On a small site, this may simply need more time. Don't assume you have a crawl budget problem.

Crawled, currently not indexed. Google crawled the page but hasn't added it to the index. Search Console doesn't tell you the exact reason. Check whether the page is substantially similar to another one of your pages, whether the canonical signals make sense, and whether the page offers enough on its own to deserve a place in the index.

Blocked by robots.txt. Your robots.txt file is preventing Google from crawling the URL. Check yoursite.com/robots.txt for a rule disallowing the page's path.

Excluded by noindex. A noindex directive in the page's HTML or headers is telling Google not to index it. Sometimes that's intentional, so check if you expected the page to appear.

Duplicate without user-selected canonical. Google sees this page as a duplicate of another and picked a different URL as canonical. If you wanted this one to be canonical, check your canonical tags and the other URL involved.

Page with redirect. The URL redirects elsewhere. Inspect the destination URL instead, since that's the one that can actually appear in search.

Server error. Google couldn't fetch the page because the server returned an error. Fix that first.

None of these automatically mean something is wrong. A noindex page or a redirected URL may be behaving exactly as intended.

Compare the indexed version with the live page

Easy to miss when troubleshooting a recent fix.

URL Inspection shows what Google knew from its last crawl. Test Live URL checks whether the current version of the page can be accessed and processed right now.

If you removed an accidental noindex tag this morning, the indexed information may still reflect the old version. A successful live test just means Google can currently access the page and that it passes those checks, not that the page has already been added to the index.

Check the page itself before requesting anything

Once you know which situation applies, look at the actual page.

Is it reachable in a normal browser without logging in? Is there a noindex tag that shouldn't be there? Does the canonical point to the URL you actually want indexed? Is the page linked from anywhere else on your site?

A sitemap helps Google discover a URL. It isn't a guarantee of crawling or indexing. Internal links can also help Google discover the page and understand how it fits into your site.

Request indexing with the right expectations

Once the page is ready, accessible, and the actual problem is fixed, go back to URL Inspection and click Request Indexing.

This asks Google to crawl the URL. It doesn't guarantee indexing, and clicking it again and again won't speed anything up. If the underlying issue hasn't changed, you're just repeating the request.

If it still isn't indexed

Go back to whichever status Search Console gave you and treat it as what it actually is. If Google hasn't crawled the page yet, it may just need time. If it's been crawled but not indexed, take a closer look at content, duplication, and canonical signals. And if something specific is blocking it, robots.txt, noindex, a redirect, a server error, fix that first.

The goal isn't to make Search Console say "indexed" as fast as possible. It's to understand why it isn't indexed before you start changing things that might not be broken at all.

References

Google Search Console Help, Inspect and troubleshoot a single page

Google Search Console Help, URL Inspection tool

Sample 2: API documentation
URL Inspection API index.inspect

The index.inspect method returns Google's indexed information about a single URL. It's the programmatic version of URL Inspection inside Search Console, useful when you need to check indexing status across many URLs without opening each one by hand.

Here's what this method doesn't do. It only returns information about the indexed version of a URL, not a live test. It can't tell you whether a fix you just made actually works on the page right now. To check the current state of the page, you still need a live test through URL Inspection in Search Console.

Endpoint

POST https://searchconsole.googleapis.com/v1/urlInspection/index:inspect

Authorization

Requires OAuth authorization with either the webmasters or webmasters.readonly scope. Use webmasters.readonly if your integration only reads inspection data and doesn't need to change anything in Search Console.

Request body

inspectionUrl (string, required). The full URL to inspect. Must belong to the property specified in siteUrl.

siteUrl (string, required). The Search Console property this URL belongs to. Use the full prefix for a URL-prefix property, such as https://www.example.com/, or sc-domain:example.com for a Domain property.

languageCode (string, optional). An IETF BCP-47 language code for translated issue messages, such as en-US. Defaults to en-US.

Example request body

{
  "inspectionUrl": "https://example.com/blog/how-to-check-indexing",
  "siteUrl": "https://example.com/"
}

Each request inspects one URL. If you're checking many URLs, your application needs a separate call for each one.

Response

A successful response returns a UrlInspectionResult object. The fields you'll use most sit under indexStatusResult.

verdict. High-level result for the inspection. PASS corresponds to a valid result in Search Console.

coverageState. A description of the URL's indexing status, such as Submitted and indexed or Crawled, currently not indexed.

robotsTxtState. Whether robots.txt allows Google to crawl the URL.

indexingState. Whether a noindex rule is blocking the URL from being indexed.

pageFetchState. Whether Google successfully fetched the page during its last crawl.

googleCanonical. The URL Google selected as canonical, if available.

userCanonical. The canonical URL declared by the page or site, if one was declared.

lastCrawlTime. When Google last crawled the URL.

If googleCanonical and userCanonical don't match, Google chose a different canonical URL than the one the page declares. Worth checking when you're investigating duplicate or canonicalization issues.

Quota

The URL Inspection API allows 2,000 queries per day and 600 per minute per Search Console property. A separate project-level limit also applies, 10,000,000 queries per day and 15,000 per minute. If you're checking indexing status across a large site, prioritize the URLs that actually matter instead of inspecting every page on a schedule.

What this method is good for, and what it isn't

Use it to track indexing status across many URLs over time, like flagging pages that quietly moved from indexed to not indexed or catching changes in canonicalization.

Don't use it to confirm that a fix you just made actually worked. Since it doesn't run a live test, a page you fixed five minutes ago may still show Google's older, indexed version.

References

Google for Developers, Method index.inspect, Search Console API

Google for Developers, UrlInspectionResult, Search Console API

Google for Developers, Usage Limits, Search Console API

Google Search Central Blog, Welcoming the new Search Console URL Inspection API

Sample 3: UX microcopy
Rewriting Confusing Search Console Messages

This is a short set of before and after rewrites based on real messages I ran into while using Google Search Console. Each one tells you something true, but the label alone doesn't always tell you what it means for you or what to do next.

"Validation Not Started"

This appears next to indexing issues in the Page indexing report. It's easy to read it as a problem with your site, when it's actually describing the status of Google's validation process. Not started means one or more instances of the issue have never been included in a validation request. It doesn't mean the issue hasn't been fixed. Google can also detect fixes during normal crawling without a validation request.

Rewrite

"Not yet validated. Fix the issue, then click Validate fix if you want Google to check your changes."

This keeps the focus on the validation process instead of making the reader second-guess whether something's broken.

"Sitemaps Couldn't fetch"

This appears when Search Console can't fetch a submitted sitemap. The label doesn't tell the reader whether the problem is the URL, access to the sitemap, the server, or something else entirely.

Rewrite

"We couldn't fetch this sitemap. Check the URL and make sure Google can access it, then resubmit."

At least this gives the reader a starting point, rather than assuming the sitemap itself is the problem.

"Page fetch Failed Redirect error"

Shown in URL Inspection when Google reports a problem following a redirect. The message can be confusing when the indexed information reflects a previous crawl, but the page works normally now.

Rewrite

"Google couldn't follow this redirect during its last crawl. Run a live test below to check whether this is still happening."

This makes the timing obvious and points to the next useful check, instead of letting the reader assume the old crawl result still applies.

Why these matter

None of these messages are necessarily factually wrong. They're just written from the system's point of view instead of the person reading it.

Good technical microcopy answers the question underneath the message, not just what happened, but what the reader should do about it and whether they should even be worried yet.