In my last post, I explained how to build a simple academic website. If you followed that tutorial, your website should be online and available to everybody. Yet, you may have realized that your website doesn’t show up when you type your name into Google, which is a shame as this is probably what most people will do if they want to know more about you and your research.

Indeed, Google relies on automated bots to discover your site by following links from other already-indexed pages. Once found, the bots “crawl” your code and “index” your content into Google’s massive database of the web. The ranking itself is then determined by algorithms that weigh factors like content relevance, mobile-friendliness, and site speed. Crucially, Google looks for “authority,” which is earned when other reputable websites link back to yours as a trusted source. If your webpage is fairly new, it is likely that the Google bots have not yet visited your website, and if there are very few other websites pointing to yours, it is possible that they will never visit your webpage.

A core pillar of Search Engine Optimization (SEO) is link building, which focuses on increasing your site’s visibility through external connections. By placing your URL on your social profiles and asking your co-authors to link to your website on their personal webpages, you create backlinks that act as digital “roadmaps” for Google’s crawlers to discover your content. Beyond just finding you, these links build Domain Authority.

In this post, I will explain a technique that will speed up the process of being discovered by Google’s crawler. By manually connecting your site to Google Search Console (GSC), you can prove ownership, submit your content structure, and “force” Google to crawl your pages.

Follow this step-by-step guide to get indexed in minutes.

Step 1: Verification (Proving You Own the Site)

Before Google gives you data on your site, you must prove you control it. While there are several ways to do this, two methods work best for GitHub repositories.

In Search Console, select the “URL Prefix” property type and enter your full URL (e.g., https://<yourgithubusername>.github.io).

Option A: The HTML Tag Method (Fastest for Jekyll)

This is the most reliable method if you are using a theme or Jekyll.

  1. In GSC, expand the HTML tag option.
  2. Copy the meta tag provided. It looks like: <meta name="google-site-verification" content="your_unique_code" />
  3. Go to your GitHub repository and open your index.html (or _layouts/default.html for Jekyll).
  4. Paste the code inside the <head> section.
  5. Commit the change and wait about 60 seconds.
  6. Return to Search Console and click Verify.

Option B: The HTML File Method

This is a “cleaner” way to verify if you don’t want to edit your code directly.

  1. In GSC, choose the HTML file method and download the provided file (e.g., google12345.html).
  2. In your GitHub repo, click Add file > Upload files.
  3. Drag and drop the file into the root of your repository.
  4. Commit the changes.
  5. Wait for the GitHub Pages build to finish, then click Verify in GSC.

Step 2: Submit Your Sitemap

A sitemap is a map of your website that tells Google exactly which pages are important. If you don’t know how to generate your sitemap, you can have a look here.

  1. Navigate to your GSC dashboard.
  2. In the left sidebar, under the Indexing section, click Sitemaps.
  3. In the “Add a new sitemap” box, enter the path to your sitemap. For most GitHub Pages sites, this is simply: sitemap.xml
  4. Click Submit.

Troubleshooting: If you see a “Couldn’t fetch” error, don’t panic. GitHub’s cache sometimes takes a little while to update. Wait an hour and try submitting it again.

Step 3: Request Indexing

If you’ve just launched your site, you don’t want to wait weeks for Google’s robots to find you naturally. You can request a “priority crawl” instead.

  1. Locate the URL Inspection search bar at the very top of the GSC dashboard.
  2. Type in your full homepage URL and hit Enter.
  3. Google will likely tell you “URL is not on Google.”
  4. Click the Request Indexing button.

A small pop-up will appear while Google performs a live test. Once finished, your URL is added to the priority queue. You’re all set!

What’s Next?

Google usually takes 24 to 72 hours to process these requests. Check back in a few days to see which keywords people are using to find your site!

Appendix: How to Generate Your Sitemap

A sitemap is a simple XML file that lists all your website’s URLs. It tells Google which pages are the most important and how often they are updated. Since GitHub Pages sites are built differently depending on the user, choose the option below that matches your setup.

Option 1: Using Jekyll (The GitHub Pages Standard)

If using Jekyll, this is the most efficient method as it updates itself every time you add a new post or page. Note that if you followed my previous tutorial, your sitemap is already built, and this was done using this solution.

A. Add the Plugin to your Dependencies

To use a plugin, Jekyll must first download the necessary code. Open the file named Gemfile in your root directory and add this line:

gem "jekyll-sitemap"

Crucial Note on Gemfile.lock: If your repository contains a Gemfile.lock, GitHub Actions will expect it to match your Gemfile exactly. You have two ways to sync them:

  • Local Update (Recommended): Run bundle install on your computer and commit the updated Gemfile.lock.
  • Web Interface: If you only use the GitHub website, you should delete the Gemfile.lock from your repository after editing the Gemfile. GitHub will then generate a fresh one during the next build.

B. Edit your Configuration

Now you must tell Jekyll to actually activate the plugin. Open _config.yml and add jekyll-sitemap to your plugins list. It should look like this:

plugins:
  - jekyll-sitemap

C. Define your URL

For the sitemap to generate valid absolute links (required by search engines), your base URL must be defined in _config.yml:

url: "https://<yourgithubusername>.github.io"

D. Commit and Verify

Push your changes. Once the GitHub Actions “deploy” job completes:

  1. Navigate to https://<yourgithubusername>.github.io/sitemap.xml.
  2. You should see an XML file listing all your posts and pages.

Option 2: Using an Online Generator (For Plain HTML)

If you are manually creating .html files without a static site generator, you can use a “crawler” to build the file for you.

  1. Scan your Site: Visit a tool like xml-sitemaps.com.
  2. Enter your URL: Type in your full GitHub Pages address and start the scan.
  3. Download & Upload: Download the resulting sitemap.xml file and upload it directly to the root folder of your GitHub repository.
  4. Manual Updates: Remember that if you add a new page (e.g., about.html), you must regenerate and re-upload this file so Google knows the new page exists.

How to Verify It Works

Once you have pushed your changes, it is important to verify the file is live before submitting it to Google Search Console.

  • The Test: Go to https://<yourgithubusername>.github.io/sitemap.xml in your browser.
  • The Goal: You should see a page of code starting with <urlset> containing a list of your site’s links.
  • Troubleshooting: If you see a 404 Error, ensure the file is in the main directory (not inside a folder like /assets/) and that the filename is strictly lowercase: sitemap.xml.