SEO on kenji.blog

A Strategy for Rewriting Past Tech Articles Using Google Search Console

Sat, 12 Sep 2026 12:00:00 +0900

1. Introduction: The Importance of Rewriting in Tech Blogs and the Data-Driven Approach

When running a technical blog or a developer-oriented owned media, “rewriting past articles” is just as important as, or perhaps even more important than, continuously writing new articles. Especially in IT and technical topics, information becomes obsolete quickly, and it is not uncommon for code snippets or API specifications written a few years ago to be deprecated today. However, simply updating past articles blindly will not maximize traffic from search engines.

Therefore, this article explains an advanced strategy to drastically improve search rankings and click-through rates (CTR) by identifying technical articles that should be rewritten. We will use a data-driven and mathematical approach, leveraging data from Google Search Console (GSC) and Google Analytics 4 (GA4).

Specifically, we will comprehensively cover everything from how to discover “missed opportunity articles” with low CTR relative to their impressions (display counts) by integrating GSC and GA4 data using Python and BigQuery, to how to efficiently fill content gaps by identifying keywords missing in H2 and H3 headings using TF-IDF analysis in NLP (Natural Language Processing).

2. Gap Analysis Between Expected CTR and Actual CTR (Introduction of a Mathematical Model)

One of the most fundamental metrics in SEO is the “Click-Through Rate (CTR) relative to search ranking”. Generally, if a search ranking is 1st, the CTR is around 25-30%, for 2nd it is about 15%, and it drops sharply after that. This relationship between ranking and CTR can be modeled as a distribution following a Power Law.

It is known that the expected click-through rate $CTR(r)$ for ranking $r$ can be approximated by the following formula:

$$ CTR(r) = a \cdot r^{-b} $$

Here, $a$ represents the expected CTR when ranked 1st (e.g., $0.30$ for 30%), and $b$ represents the decay parameter (generally between $1.0$ and $1.5$).

The most effective approach when selecting articles to rewrite is to find articles (keywords) where the “actual CTR” falls significantly below this “expected CTR”. For example, if a search ranking is 3rd (expected CTR of about 10%) but the actual CTR is only 2%, it is highly likely that either the search intent is misaligned with the title and description, or clicks are being stolen by competitive factors such as rich snippets.

The following graph is an image showing the divergence between expected CTR and actual CTR in a certain technical blog.

xychart-beta
title Expected CTR vs Actual CTR by Position
x-axis ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
y-axis "CTR (%)" 0 --> 35
line [30.5, 15.2, 10.1, 7.5, 5.2, 4.1, 3.2, 2.5, 2.0, 1.5]
bar [32.1, 14.0, 8.5, 4.0, 5.0, 2.1, 1.5, 1.0, 1.2, 0.5]

(* The line graph shows the expected CTR, and the bar graph shows the actual CTR. You can confirm that it falls significantly below at the 4th and 8th positions.)

3. Automatic Extraction of Search Performance Data Using GSC API (Python)

While it is possible to download CSVs from the GSC web UI for analysis, the best approach for large-scale blogs or continuous analysis is to build a system that automatically extracts data with Python using the GSC API.

Below is a Python snippet using google-api-python-client to retrieve page-level and query-level performance data (clicks, impressions, CTR, average position) over a specific period.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import pandas as pd
from google.oauth2 import service_account
from googleapiclient.discovery import build

def get_gsc_data(key_path, site_url, start_date, end_date):
 # Load credentials and build API client
 credentials = service_account.Credentials.from_service_account_file(
 key_path, scopes=['https://www.googleapis.com/auth/webmasters.readonly']
 )
 service = build('searchconsole', 'v1', credentials=credentials)

 # Set API request payload (specify page and query as dimensions)
 request = {
 'startDate': start_date,
 'endDate': end_date,
 'dimensions': ['page', 'query'],
 'rowLimit': 25000
 }

 # Execute API
 response = service.searchanalytics().query(
 siteUrl=site_url, body=request
 ).execute()

 # Extract data from response and convert to Pandas DataFrame
 rows = response.get('rows', [])
 data = []
 for row in rows:
 keys = row['keys']
 data.append({
 'page': keys[0],
 'query': keys[1],
 'clicks': row['clicks'],
 'impressions': row['impressions'],
 'ctr': row['ctr'],
 'position': row['position']
 })

 return pd.DataFrame(data)

# Execution example
# df_gsc = get_gsc_data('credentials.json', 'https://kenji.blog/', '2026-08-01', '2026-08-31')
# print(df_gsc.head())

With this script, you can retrieve detailed data linking page URLs to search queries as a DataFrame. This makes it possible to comprehensively grasp what keywords are displaying a specific article.

4. Filtering Technical Keywords Using Regular Expressions (Regex)

An extremely powerful feature in analyzing technical blogs is GSC’s Regular Expression (Regex) filters. For example, if you write articles spanning diverse fields from frontend to backend and infrastructure, you might want to extract only “articles about errors or tutorials related to Python or Pandas” to prioritize rewriting.

Using GSC’s custom regular expression filters allows you to narrow down queries with complex conditions.

Examples of Technical Keyword Filtering:

Python-related error investigation: ^(python|pandas|numpy|matplotlib).* (error|exception|bug|not working)
AWS-related infrastructure setup: (aws|amazon web services|ec2|s3|lambda).* (setup|configuration|tutorial|how to)
Version upgrades for specific libraries: (react|vue|angular) (v17|v18|v3) (migration)

When integrating this into a GSC API request, utilize dimensionFilterGroups to apply the regular expression conditions. By making full use of this filtering, you can pinpoint high-value, problem-solving keywords where developers are “currently stuck and searching for answers”.

5. Integrating GA4 and GSC Data with BigQuery/Pandas

GSC data alone only reveals “search rankings and CTR”. To know “how long users who reached the article actually stayed, and whether they achieved a conversion (e.g., navigating to a GitHub repository or signing up for a newsletter)”, it needs to be integrated (JOINed) with Google Analytics 4 (GA4) data.

If you are storing GA4 export data and GSC bulk export data in BigQuery, you can use a SQL query like the following to combine both and extract articles that have “high impressions and decent search rankings, but a high bounce rate or short engagement time”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


WITH gsc_data AS (
 SELECT
 url AS page_path,
 SUM(impressions) AS total_impressions,
 SUM(clicks) AS total_clicks,
 AVG(sum_top_position) AS avg_position
 FROM
 `project.searchconsole.searchdata_url_impression`
 WHERE
 data_date BETWEEN '2026-08-01' AND '2026-08-31'
 GROUP BY
 url
),
ga4_data AS (
 SELECT
 REGEXP_REPLACE(
 (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location'),
 r'^https?://[^/]+', ''
 ) AS page_path,
 COUNT(DISTINCT user_pseudo_id) AS users,
 AVG((SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'engagement_time_msec')) / 1000 AS avg_engagement_sec
 FROM
 `project.analytics_123456789.events_*`
 WHERE
 event_name = 'page_view'
 GROUP BY
 page_path
)

SELECT
 g.page_path,
 g.total_impressions,
 g.total_clicks,
 SAFE_DIVIDE(g.total_clicks, g.total_impressions) AS ctr,
 g.avg_position,
 a.users,
 a.avg_engagement_sec
FROM
 gsc_data g
JOIN
 ga4_data a ON g.page_path = a.page_path
WHERE
 g.total_impressions > 1000
 AND g.avg_position BETWEEN 3 AND 15
ORDER BY
 g.total_impressions DESC

Using these results, classify targets for rewriting with a matrix like the following:

High Impression, Low CTR, High Engagement: Articles where readers are satisfied as long as they click through from the search results. Modifying the title and meta description should be the top priority.
High CTR, Low Engagement: Articles that get clicked, but content is disappointing, causing users to leave. A large-scale rewrite of the main text is needed, such as improving the lead paragraph, updating to the latest code, and enhancing information comprehensiveness (adding H2/H3).

6. Content Gap Analysis Using NLP and TF-IDF

Once the articles to be rewritten are identified, the next step is to analyze “specifically what headings (H2/H3) or keywords should be added”. Rather than relying on intuition, we leverage TF-IDF (Term Frequency-Inverse Document Frequency) in Natural Language Processing (NLP).

TF-IDF is a statistical measure used to evaluate how important a word is to a document within a collection.

$$ TF\text{-}IDF(t, d) = tf(t, d) \times \log\left(\frac{N}{df(t)}\right) $$

Here,

$tf(t, d)$ is the term frequency of word $t$ in document $d$
$N$ is the total number of documents
$df(t)$ is the number of documents containing the word $t$

Approach:

Obtain the text data of the top 10 articles (competitor sites) for the target keyword via scraping, etc.
Prepare the text data of the target article on your own site.
Using Python’s scikit-learn TfidfVectorizer, extract keywords (feature words) that appear with high scores commonly across the top competitor articles, but are missing or have significantly low scores in your own site’s article.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
import numpy as np

# documents = [Text of own site, Text of competitor article 1, Text of competitor article 2, ...]
# Assuming a list of texts already tokenized (e.g., using morphological analysis like MeCab for Japanese)

def extract_missing_keywords(documents):
 vectorizer = TfidfVectorizer(max_df=0.9, min_df=2)
 tfidf_matrix = vectorizer.fit_transform(documents)

 feature_names = vectorizer.get_feature_names_out()

 # Calculate the average TF-IDF score of competitor articles (index 1 and onwards)
 competitor_mean_tfidf = np.mean(tfidf_matrix[1:].toarray(), axis=0)

 # Get the TF-IDF score of own site's article (index 0)
 my_article_tfidf = tfidf_matrix[0].toarray()[0]

 # Calculate the gap for words that are important to competitors but missing (or scarce) in your own site
 gap_scores = competitor_mean_tfidf - my_article_tfidf

 # Extract the top words with the largest gaps
 df_gap = pd.DataFrame({'keyword': feature_names, 'gap_score': gap_scores})
 df_gap = df_gap.sort_values(by='gap_score', ascending=False)

 return df_gap.head(20)

# Example: missing_keywords = extract_missing_keywords(processed_docs)
# print(missing_keywords)

Through this analysis, you can quantitatively discover topic omissions (content gaps), such as “Top-ranking articles actually mention ‘How to deploy to a Docker container’ and ‘Building a CI/CD pipeline’, but my article doesn’t touch on them”.

The discovered important keywords shouldn’t just be scattered throughout the text. Instead, they should be added as meaningful sections using H2 or H3 headings (Heading tags), and by writing detailed technical explanations and code snippets for these headings, you can dramatically improve your Google evaluation.

7. Data Pipelines and Continuous Improvement Cycle

The processes explained so far are not meant to be executed just once. Building them into a pipeline for continuous execution is key to SEO success. Below is a Mermaid flowchart showing the overall architecture and operational flow.

flowchart TD
A["GSC API Data (Impressions, Clicks, Positions)"] --> C["BigQuery / Data Warehouse"]
B["GA4 Export Data (Pageviews, Engagement Time)"] --> C
C --> D["Python / Pandas Data Join & Analysis"]
D --> E["Identify High-Impression / Low-CTR Articles"]
E --> F["NLP Competitor Scraping & TF-IDF Keyword Extraction"]
F --> G["Optimize H2/H3 Tags & Rewrite Content"]
G --> H["Publish Updated Article"]
H --> I["Monitor CTR Changes (Expected vs Actual)"]
I --> |"Feedback Loop"| A

By systematizing this entire flow—from data collection from GSC and GA4, target selection through analysis, content optimization via NLP, to result monitoring—a blog media becomes an asset that continues to grow automatically.

8. Conclusion and Future Outlook

Rewriting technical articles utilizing Google Search Console is not merely about correcting text. It is advanced engineering that presents optimal solutions to the black box of search engine algorithms by fully leveraging data and mathematical models.

To summarize the methods explained in this article:

Identify articles with a large potential impact for correction by calculating the divergence between expected CTR and actual CTR.
Automatically extract performance data using the GSC API and Python.
Join with GA4 engagement data on BigQuery to correct the main text of articles with high bounce rates.
Discover content gaps with competitors through NLP analysis using TF-IDF and optimize headings (H2/H3).

Technology trends are constantly changing. To accurately respond to the errors and challenges readers are currently facing, we highly recommend incorporating strategic rewriting backed by data into your daily operations.

Hugo Blog SEO: Frontmatter Settings to Dramatically Increase Traffic

Sat, 12 Sep 2026 12:00:00 +0900

Hugo is one of the world’s fastest static site generators (SSG) written in Go. Its overwhelming build speed and flexible template system have garnered high support from many engineers and bloggers. However, simply generating and displaying a site quickly is not enough to be highly evaluated by search engines (like Google or Bing) and deliver articles to users.

To improve search rankings, increase diffusion power on social media, and consequently dramatically increase blog traffic, meticulous SEO (Search Engine Optimization) measures are essential. The heart of SEO in Hugo is the integration of the Frontmatter, which is written at the beginning of each markdown article, and the Layouts (templates), which interpret it and expand metadata into the <head> tag of the HTML.

In this article, we will thoroughly explain in an overwhelming volume of over 10,000 characters how to maximize Hugo’s functions and implement advanced SEO measures, ranging from frontmatter settings to various meta tags, OGP (Open Graph Protocol), Twitter Cards, and outputting structured data using JSON-LD.

1. Mathematical Background of SEO and Traffic

Before diving into specific implementations, let’s mathematically understand why detailed SEO metadata is important. The search traffic $T$ that a website can acquire is determined by the search volume of the target keyword and the Click-Through Rate (CTR) based on the search ranking.

This can be expressed by the following formula:

$$ T = \sum_{i=1}^{n} V_i \times CTR(R_i) $$

$V_i$ : Monthly search volume for keyword $i$
$R_i$ : Search ranking for keyword $i$
$CTR(R_i)$ : Click-Through Rate at ranking $R_i$

Among these, the search ranking $R_i$ depends on many factors such as content quality and backlinks (PageRank), but Google’s early PageRank algorithm is modeled as follows:

$$ PR(u) = \frac{1-d}{N} + d \sum_{v \in B(u)} \frac{PR(v)}{L(v)} $$

$PR(u)$ : PageRank of page $u$
$d$ : Damping factor (usually 0.85)
$B(u)$ : Set of pages linking to page $u$
$L(v)$ : Number of outbound links from page $v$

What’s important here is how to maximize the click-through rate $CTR(R_i)$ in addition to the effort to raise the search ranking $R_i$. By optimizing titles and snippets (description) displayed on search results (SERPs) and eyecatch images (OGP) when shared on social media, it is possible to intentionally raise $CTR(R_i)$. SEO settings in frontmatter are directly linked to maximizing this $CTR$.

2. Hugo’s Build Process and the Role of Frontmatter

Hugo reads the frontmatter (YAML/TOML/JSON) in the markdown file and passes it to the template engine as page variables. Let’s first understand this flow of information visually.

flowchart TD
A["Markdown File"] --> B["Frontmatter Parsing"]
A --> C["Content Parsing"]
B --> D["Hugo Page Variables (.Title, .Params)"]
C --> D
E["layouts/partials/head.html"] --> F["Go Template Engine"]
D --> F
F --> G["Final HTML <head> Tag"]
G --> H["Googlebot / Crawlers"]
G --> I["Social Media Scrapers (OGP)"]

In this way, the values set in the frontmatter are passed to head.html as variables like .Title and .Params.description, and output as the final HTML metadata. Therefore, SEO success consists of two steps: “defining appropriate information in the frontmatter” and “correctly converting it to HTML with templates”.

3. Basic Metadata Settings: Title, Description, Canonical URL

The most basic tags for search engines to understand page content are <title> and <meta name="description">. Also, <link rel="canonical"> is essential to avoid penalties for duplicate content.

3.1. Frontmatter Setting Example

We prepare fields specialized for SEO in the article’s frontmatter.

1
2
3
4
5
6
7


---
title: "Hugo Blog SEO: Frontmatter Settings to Dramatically Increase Traffic"
seo_title: "Complete Guide to Hugo SEO: Boost Traffic with Frontmatter" # Optional: For search engines
description: 'Advanced SEO techniques utilizing Hugo frontmatter. A detailed explanation of OGP, JSON-LD, and metadata settings.'
slug: "hugo-seo-frontmatter-tips"
canonicalUrl: "https://example.com/post/hugo-seo-frontmatter-tips/" # Explicit canonical URL
---

3.2. Implementation of `layouts/partials/head.html`

We create an HTML template to correctly output these variables.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


<!-- Title optimization -->
{{ $title := .Title }}
{{ if .Params.seo_title }}
 {{ $title = .Params.seo_title }}
{{ end }}
<title>{{ $title }} | {{ .Site.Title }}</title>

<!-- Description optimization -->
{{ $description := .Summary | plainify | truncate 120 }}
{{ if .Params.description }}
 {{ $description = .Params.description }}
{{ end }}
<meta name="description" content="{{ $description }}">

<!-- Canonical URL (Normalization) -->
{{ $canonical := .Permalink }}
{{ if .Params.canonicalUrl }}
 {{ $canonical = .Params.canonicalUrl }}
{{ end }}
<link rel="canonical" href="{{ $canonical }}">

<!-- Robot control (e.g., noindex settings) -->
{{ if .Params.noindex }}
<meta name="robots" content="noindex, nofollow">
{{ else }}
<meta name="robots" content="index, follow">
{{ end }}

By using Hugo’s .Summary as a fallback, even if description is not set, the introductory text of the article can be automatically extracted.

To display articles in an attractive card format when shared on SNS like Twitter (X) and Facebook, Open Graph Protocol (OGP) and Twitter Cards settings are indispensable. This is also dynamically generated from the frontmatter.

4.1. Issues with Built-in Templates

Hugo has a convenient built-in template {{ template "_internal/opengraph.html" . }}, but it lacks customizability and may not fit specific requirements or Japanese environments. Therefore, we strongly recommend implementing your own OGP tags within head.html.

4.2. Specifying Images in Frontmatter

1
2
3
4
5


---
image: "img/eyecatch.jpg"
images:
 - "img/eyecatch-large.jpg" # For multiple images or absolute paths
---

4.3. Custom Implementation Code for OGP and Twitter Cards

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


<!-- Open Graph Protocol -->
<meta property="og:title" content="{{ $title }}">
<meta property="og:description" content="{{ $description }}">
<meta property="og:type" content="{{ if .IsPage }}article{{ else }}website{{ end }}">
<meta property="og:url" content="{{ .Permalink }}">
<meta property="og:site_name" content="{{ .Site.Title }}">

<!-- Resolving OGP Image -->
{{ $ogImage := "" }}
{{ if .Params.image }}
 {{ $ogImage = .Params.image | absURL }}
{{ else if .Params.images }}
 {{ $ogImage = index .Params.images 0 | absURL }}
{{ else if .Site.Params.defaultImage }}
 {{ $ogImage = .Site.Params.defaultImage | absURL }}
{{ end }}

{{ if $ogImage }}
<meta property="og:image" content="{{ $ogImage }}">
<meta name="twitter:image" content="{{ $ogImage }}">
<meta name="twitter:card" content="summary_large_image">
{{ else }}
<meta name="twitter:card" content="summary">
{{ end }}

<!-- Twitter Cards -->
<meta name="twitter:title" content="{{ $title }}">
<meta name="twitter:description" content="{{ $description }}">
{{ if .Site.Params.twitterAccount }}
<meta name="twitter:site" content="@{{ .Site.Params.twitterAccount }}">
{{ end }}

By interposing the absURL function, an image URL specified by a relative path is converted to an absolute path. Since absolute paths are mandatory in OGP, this process is extremely important.

5. Implementation of Structured Data (JSON-LD)

In current SEO, JSON-LD (JavaScript Object Notation for Linked Data) has become mainstream as a technology to accurately convey the semantic structure of a page to search engines. By setting this up, rich snippets (star ratings, author name, publication date, etc.) are more likely to be displayed in search results.

5.1. Structure of JSON-LD

For blog articles, two main schemas are implemented: the Article schema and the BreadcrumbList schema.

flowchart TD
A["Schema.org Definitions"] --> B["Article Schema"]
A --> C["BreadcrumbList Schema"]
B --> D["headline"]
B --> E["datePublished"]
B --> F["dateModified"]
B --> G["author"]
B --> H["image"]
C --> I["ListItem 1"]
C --> J["ListItem 2"]
I --> K["position: 1"]
I --> L["name: Home"]
J --> M["position: 2"]
J --> N["name: Category / Blog"]

5.2. JSON-LD Generation in Hugo Templates

Leverage frontmatter variables like .Date and .Lastmod to dynamically output JSON-LD. Describe it in head.html using the <script type="application/ld+json"> tag.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


{{ if .IsPage }}
<script type="application/ld+json">
{
 "@context": "https://schema.org",
 "@type": "Article",
 "mainEntityOfPage": {
 "@type": "WebPage",
 "@id": "{{ .Permalink }}"
 },
 "headline": "{{ .Title | htmlEscape }}",
 "description": "{{ $description | htmlEscape }}",
 "image": "{{ $ogImage }}",
 "datePublished": "{{ .Date.Format "2006-01-02T15:04:05-07:00" }}",
 "dateModified": "{{ .Lastmod.Format "2006-01-02T15:04:05-07:00" }}",
 "author": {
 "@type": "Person",
 "name": "{{ if .Params.author }}{{ .Params.author }}{{ else }}{{ .Site.Params.author }}{{ end }}"
 },
 "publisher": {
 "@type": "Organization",
 "name": "{{ .Site.Title }}",
 "logo": {
 "@type": "ImageObject",
 "url": "{{ .Site.Params.logo | absURL }}"
 }
 }
}
</script>

<!-- BreadcrumbList Schema -->
<script type="application/ld+json">
{
 "@context": "https://schema.org",
 "@type": "BreadcrumbList",
 "itemListElement": [
 {
 "@type": "ListItem",
 "position": 1,
 "name": "Home",
 "item": "{{ .Site.BaseURL }}"
 }
 {{ $position := 2 }}
 {{ range .Params.categories }}
 ,{
 "@type": "ListItem",
 "position": {{ $position }},
 "name": "{{ . }}",
 "item": "{{ "categories/" | relLangURL }}{{ . | urlize | lower }}/"
 }
 {{ $position = add $position 1 }}
 {{ end }}
 ,{
 "@type": "ListItem",
 "position": {{ $position }},
 "name": "{{ .Title | htmlEscape }}",
 "item": "{{ .Permalink }}"
 }
 ]
}
</script>
{{ end }}

When expanding strings within JSON-LD, the key is to use htmlEscape (or jsonify) to prevent breaking the double quotes. This prevents JSON syntax errors regardless of what symbols are used in the frontmatter.

6. Advanced Techniques for Utilizing Frontmatter

In addition to basic SEO metadata, Hugo’s frontmatter has features to realize more advanced SEO strategies.

6.1. Redirect Processing via Aliases

If you have migrated to Hugo from a past blog service or changed the structure of permalinks, you need to redirect access from the old URLs to the new URLs. By using the aliases field in Hugo, you can automatically generate HTTP-Equiv refresh (meta redirect) pages for the old URLs.

1
2
3
4
5
6
7


---
title: "New Article Title"
slug: "new-seo-post"
aliases:
 - "/old-category/old-seo-post/"
 - "/2020/05/12/seo-tips/"
---

6.2. Article Expiration Dates and Scheduling

For limited-time campaign articles or information that loses value as it gets older, setting an expiryDate makes it possible to exclude them from the build results and not display them on the site (to return a 404) after a specific date and time. This prevents low-quality, outdated content from remaining in the index and lowering the overall evaluation of the site.

1
2
3
4
5


---
title: "Exclusive SEO Techniques for 2026"
publishDate: "2026-01-01T00:00:00Z"
expiryDate: "2026-12-31T23:59:59Z"
---

7. Site Performance and Core Web Vitals

In SEO, page loading speed is just as important as tag optimization. Google incorporates Core Web Vitals (LCP, FID/INP, CLS) as ranking factors.

Hugo, which is a static site, originally has excellent TTFB (Time to First Byte), but image optimization is mandatory for blogs that use a lot of images. By combining Hugo’s powerful Image Processing feature with frontmatter, conversion to Next-gen formats (such as WebP) and resizing can be automated at build time.

For example, you can create a shortcode that automatically generates WebP images on the template side from the image path specified in the frontmatter. This can dramatically increase your SEO evaluation.

8. Conclusion

In blog operations using Hugo, the frontmatter is not just an “enumeration of configuration values” but a “control panel” for interacting with search engines and SNS.

By completely implementing the following points explained in this article, the SEO foundation of your blog will become solid.

Dynamic Generation of Basic Metadata: Reliable output of Title, Description, and Canonical.
Optimization of Social Sharing: CTR improvement through custom implementation of OGP and Twitter Cards.
Full Support for Structured Data: Rich result support through JSON-LD (Article, Breadcrumb).
Advanced Traffic Management: Robot control with meta tags and redirects using Aliases.

Search engine algorithms are evolving daily, but the fundamental principle of SEO, which is to provide signals for search engines to “correctly understand the content of the page”, remains unchanged. By mastering Hugo’s flexible template engine and frontmatter, continue to broadcast those signals with the highest quality, and dramatically increase your blog’s traffic.

Indie App Promotion Strategy: How to Leverage a Tech Blog

Sat, 12 Sep 2026 12:00:00 +0900

After building an amazing application as a solo developer, the biggest wall many face is the cruel reality that “nobody knows about the app.” No matter how refined the codebase is, or how beautiful the UI/UX is, without a promotion strategy, it will never reach the eyes of users.

For modern indie developers (Indie Hackers), one of the most powerful and sustainable promotion channels is a “tech blog.” In this article, we will explain in depth how to make a tech blog function not just as a development memo, but as a strategic inbound marketing engine, covering everything from technical implementation (SEO metadata design, A/B testing architecture, tracking with GA4 and PostHog) to mathematical evaluation models.

1. SEO Strategy to Turn Your Tech Blog into a “Traffic Generator”

SEO (Search Engine Optimization) for a tech blog is not simply about sprinkling keywords. It requires a programmatic approach to accurately convey the semantics (meaning) of the content to search engines (Googlebot) and social media crawlers.

1.1 Optimization of Open Graph Protocol (OGP)

When technical articles are shared on X (formerly Twitter), Hacker News, Zenn, etc., dynamically generating OGP is essential to maximize the click-through rate (CTR). If you are using the Next.js App Router, use the generateMetadata function to output optimized OGP for each article.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


// app/blog/[slug]/page.tsx
import { Metadata } from 'next';

export async function generateMetadata({ params }: { params: { slug: string } }): Promise<Metadata> {
 const post = await fetchPostBySlug(params.slug);

 return {
 title: `${post.title} | My Indie App Dev Blog`,
 description: post.excerpt,
 openGraph: {
 title: post.title,
 description: post.excerpt,
 url: `https://example.com/blog/${params.slug}`,
 siteName: 'Indie Dev Blog',
 images: [
 {
 url: `https://example.com/api/og?title=${encodeURIComponent(post.title)}`,
 width: 1200,
 height: 630,
 alt: post.title,
 },
 ],
 locale: 'ja_JP',
 type: 'article',
 authors: ['Kenji'],
 },
 twitter: {
 card: 'summary_large_image',
 title: post.title,
 description: post.excerpt,
 creator: '@kenjinote',
 },
 };
}

1.2 Implementation of Structured Data Using JSON-LD

To convey the context to search engines that “this is a technical article and at the same time a promotion for a software app,” we embed structured data using JSON-LD (JavaScript Object Notation for Linked Data) into the page. By combining the SoftwareApplication schema, which has a link to the app’s landing page, along with the Article schema, we aim to acquire rich results.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


// app/blog/[slug]/page.tsx (inside the component)
const jsonLd = {
 "@context": "https://schema.org",
 "@graph": [
 {
 "@type": "TechArticle",
 "headline": post.title,
 "image": [
 `https://example.com/api/og?title=${encodeURIComponent(post.title)}`
 ],
 "datePublished": post.publishedAt,
 "dateModified": post.updatedAt,
 "author": [{
 "@type": "Person",
 "name": "Kenji",
 "url": "https://example.com/about"
 }]
 },
 {
 "@type": "SoftwareApplication",
 "name": "My Awesome App",
 "operatingSystem": "Windows, macOS, Linux",
 "applicationCategory": "DeveloperApplication",
 "offers": {
 "@type": "Offer",
 "price": "0",
 "priceCurrency": "USD"
 }
 }
 ]
};

export default function BlogPost({ params }) {
 return (
 <article>
 <script
 type="application/ld+json"
 dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
 />
 {/* The body of the article continues */}
 </article>
 );
}

Through this implementation, Google interprets the page not just as text data, but as a collection of entities, understanding that a software tool for solving specific technical challenges is being introduced.

2. Funnel Design from Tutorial to Conversion

Readers of a tech blog arrive by searching for specific error messages or technical challenges (e.g., “React Context API performance optimization”). It is important to place a CTA (Call to Action) for your app naturally right after satisfying their “Search Intent.”

2.1 Visualization of the User Journey

The ideal funnel from when a reader comes from organic search to installing the app and becoming an active user is shown below.

flowchart LR
A["Organic Search (Google)"] --> B["Tech Blog Tutorial"]
B --> C["Aha! Moment (Problem Solved)"]
C --> D["CTA Click (Try my App)"]
D --> E["App Landing Page"]
E --> F["App Download / Signup"]
F --> G["Active User"]
style A fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#bbf,stroke:#333,stroke-width:2px
style D fill:#fbb,stroke:#333,stroke-width:2px
style F fill:#bfb,stroke:#333,stroke-width:2px

For example, at the end of an article titled “How to Reduce Redux Boilerplate,” you place a context-aligned CTA such as “If you are struggling with the complexity of state management, please try ‘StateViewer’, a new state management visualization tool I developed.”

2.2 Mathematical Model of Conversion Rate

The marketing results through the blog are evaluated by the following Conversion Rate ($CR$) formula.

$$ CR_{overall} = \frac{N_{active\_users}}{N_{blog\_visitors}} \times 100 $$

Breaking down the funnel, the overall conversion rate can be expressed as the product of the transition rates of each step.

$$ CR_{overall} = P(CTA|Visit) \times P(Install|CTA) \times P(Active|Install) $$

Here, $P(CTA|Visit)$ is the probability that a blog visitor clicks the CTA. The biggest leverage point to increase the conversion rate of a tech blog lies in maximizing this $P(CTA|Visit)$. To optimize this, we introduce A/B testing, which is explained in the next section.

3. Implementation of Edge A/B Testing Using Vercel Edge Config

You should not decide the wording, design, and placement of a CTA by intuition. To make data-driven decisions, we conduct A/B testing. Client-side A/B testing on the frontend causes the “flicker phenomenon” (screen flickering), so we adopt an architecture that quickly routes requests on the edge network using Vercel Edge Middleware and Edge Config.

3.1 Edge A/B Testing Architecture

The following sequence diagram shows the A/B testing flow utilizing Vercel’s edge infrastructure.

sequenceDiagram
participant U as "User (Browser)"
participant M as "Vercel Middleware (Edge)"
participant E as "Vercel Edge Config"
participant P as "Next.js Page Render"
U->>M: "GET /blog/react-hooks-tutorial"
M->>E: "Read A/B test configuration"
E-->>M: "Return active variant weights (A:50%, B:50%)"
alt "Cookie already exists"
M->>M: "Use existing variant cookie"
else "First visit"
M->>M: "Assign variant (e.g., Variant B)"
M->>M: "Set Set-Cookie header"
end
M->>P: "Rewrite to /blog/react-hooks-tutorial?variant=B"
P-->>U: "Render HTML with CTA Variant B"

3.2 Middleware Implementation Code

By using Edge Config, it is possible to switch A/B testing flags in milliseconds without redeploying.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { get } from '@vercel/edge-config';

export const config = {
 matcher: '/blog/:slug*',
};

export async function middleware(request: NextRequest) {
 // Fetch the currently active A/B test variant from Edge Config
 const ctaExperiment = await get('cta_experiment_v1');
 let variant = request.cookies.get('cta_variant')?.value;

 // If the variant is unassigned, assign it randomly
 if (!variant && ctaExperiment?.active) {
 variant = Math.random() < 0.5 ? 'A' : 'B';
 }

 // Build the URL for Rewrite
 const url = request.nextUrl.clone();
 if (variant) {
 url.searchParams.set('variant', variant);
 }

 const response = NextResponse.rewrite(url);

 // Save to Cookie to show the same variant to the same user
 if (variant && !request.cookies.has('cta_variant')) {
 response.cookies.set('cta_variant', variant, {
 maxAge: 60 * 60 * 24 * 30, // 30 days
 path: '/',
 sameSite: 'lax',
 });
 }

 return response;
}

On the blog page component side, it receives searchParams.variant and renders either a “modest text link (A)” or a “prominent graphical banner (B)” accordingly.

4. Data-Driven Growth Hacking: Implementation of GA4 and PostHog

After conducting A/B testing and guiding users to the app’s landing page, it is necessary to precisely measure its effectiveness. The era of just tracking page views is over. What is required now is “event-based” tracking and product analytics that tie together user behavior within the product.

4.1 Event Tracking with Google Analytics 4 (GA4)

GA4 has transitioned from the traditional session-based data model to an event-based one. To capture the exact moment a specific CTA in a blog post is clicked, a custom event is fired.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// components/CallToAction.tsx
'use client';

export default function CallToAction({ variant, appUrl }) {
 const handleCTAClick = () => {
 // Push event to GA4 dataLayer
 if (typeof window !== 'undefined' && window.gtag) {
 window.gtag('event', 'generate_lead', {
 event_category: 'engagement',
 event_label: 'blog_bottom_cta',
 value: 1,
 ab_variant: variant,
 });
 }
 };

 return (
 <div className={`cta-container ${variant}`}>
 <h3>Would you like to try the app I developed?</h3>
 <a href={appUrl} onClick={handleCTAClick} className="btn-primary">
 Download Now
 </a>
 </div>
 );
}

4.2 Product Analytics using PostHog

While GA4 excels at analyzing website traffic, an open-source based product analytics tool like PostHog is better suited for tracking whether “a user who flowed in from the blog actually installed the app and continues to use it a week later (retention).”

By introducing PostHog, a series of behaviors from the frontend (blog) to the backend (app’s API) can be linked together and analyzed under a single user ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Example of PostHog initialization and event tracking
import posthog from 'posthog-js';

// Initialization on the client side
if (typeof window !== 'undefined') {
 posthog.init('phc_YOUR_PROJECT_API_KEY', {
 api_host: 'https://app.posthog.com',
 loaded: (posthog) => {
 if (process.env.NODE_ENV === 'development') posthog.debug();
 }
 });
}

// Tracking upon CTA click
export const trackAppDownload = (sourceId: string, variant: string) => {
 posthog.capture('app_download_clicked', {
 source_article: sourceId,
 ab_test_variant: variant,
 timestamp: new Date().toISOString()
 });
};

Using PostHog’s powerful “Funnel” feature, you can visualize the drop-off rate for each step of “Blog View -> CTA Click -> Signup -> First Core Action Execution,” and grasp where the bottlenecks are at a glance.

4.3 Evaluation of Unit Economics (LTV and CAC)

Ultimately, it is necessary to mathematically evaluate whether the time cost (or outsourcing fee to external writers) of writing a tech blog is viable as a business. What becomes important here is the relationship between Customer Acquisition Cost (CAC) and Customer Lifetime Value (LTV).

CAC is calculated as follows. For a tech blog, direct advertising costs might be zero, but the “hours of labor × your hourly rate” spent writing should be accounted for as a cost.

$$ CAC = \frac{Total\_Cost\_of\_Content\_Creation}{Total\_Customers\_Acquired} $$

On the other hand, for a subscription-based indie app, LTV is calculated from ARPU (Average Revenue Per User) and the Churn Rate. By multiplying the Gross Margin, you get a more accurate profit-based LTV.

$$ LTV = ARPU \times \frac{1}{Churn\_Rate} \times Gross\_Margin $$

The golden rule for maintaining the health of a SaaS business or the growth of an indie app (the health of unit economics) is to satisfy the following inequality.

$$ \frac{LTV}{CAC} > 3 $$

Once a high-quality article is indexed, a tech blog will continue to generate organic traffic from search engines for a long time. In other words, as time passes, the number of acquired users (denominator) increases, and the $CAC$ has a powerful compounding effect (leverage) that approaches zero to the limit. This is the biggest reason why a tech blog becomes the ultimate promotional weapon for solo developers without financial power.

5. Conclusion

In this article, we explained the technical strategies to elevate a tech blog from a mere “diary” into a highly optimized “automated engine for attracting app users.”

SEO and Structured Data: Use OGP and JSON-LD to accurately convey the true value of your content to crawlers.
Funnel Design: Present the most relevant CTA immediately after solving the reader’s technical pain points.
Edge A/B Testing: Utilize Vercel Edge Config to search for the optimal UI without sacrificing performance.
Precise Analytics: Combine GA4 and PostHog to track “conversion” and “retention” rather than PVs, keeping the LTV/CAC ratio healthy.

Creating a wonderful product is only half of the success. The other half is “marketing as engineering” to deliver it into the hands of those who need it. Do not let your tech blog end as just a place for output, but cultivate it into the greatest asset that supports the sustainable growth of your app.

What Engineers Should Do to Grow Monthly Traffic on a Tech Blog

Sat, 12 Sep 2026 12:00:00 +0900

Introduction: Tech Blog Growth Hacking Only Engineers Can Do

Many software engineers start tech blogs, but few manage to gather a consistent number of views and maintain or expand them over a long period. Writing high-quality technical articles is a prerequisite, but the era of “write a good article and it will naturally be read” is long gone. Today’s search engine algorithms have become complex, and the flow of information on SNS is faster than ever.

However, engineers have an advantage that other professions do not. That is the ability to “understand system architecture, combine tools for automation, and analyze data programmatically.” In this article, going beyond simple writing techniques, we will treat a tech blog as a single “product” and explain in extreme and practical detail the strategies to dramatically increase monthly traffic using the power of engineering.

1. SEO Architecture for Engineer Tech Blogs

The foundational system of a blog (such as a static site generator) and the structure of its HTML are the most critical factors for search engines to interpret content correctly.

1.1 Core Web Vitals Optimization

Google has adopted page experience as a ranking factor, and Core Web Vitals (LCP, FID/INP, CLS) cannot be ignored, even for tech blogs. Tech blogs heavily use large amounts of source code blocks, mathematical formulas (MathJax / KaTeX), and explanatory diagrams. These are factors that delay page rendering.

LCP (Largest Contentful Paint): The loading speed of the main content above the fold. Use WebP or AVIF for the eye-catch image and add the fetchpriority="high" attribute to preload it. Also, huge CSS and JS files for syntax highlighting should be loaded asynchronously or designed to load only on pages where they are needed.
CLS (Cumulative Layout Shift): Layout shifts during page loading. By securing the display area for formulas and images in advance using CSS properties like aspect-ratio, you can prevent layout jank when the DOM is inserted later.
INP (Interaction to Next Paint): Responsiveness to user interactions. Heavy JavaScript (such as dynamic full-text search on the client side or executing a massive Markdown parser) must not be executed on the main thread; it is essential to offload it to a Web Worker or generate it as static HTML (SSG) during the build process.

1.2 Implementation of Structured Data (JSON-LD)

To explicitly tell search engines that the page is an “article” and “who” the author is, implement structured data in JSON-LD format. By utilizing schemas such as TechArticle or SoftwareSourceCode, your content is more likely to appear in Google’s Rich Results, improving the CTR (Click-Through Rate).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


<script type="application/ld+json">
{
 "@context": "https://schema.org",
 "@type": "TechArticle",
 "headline": "What Engineers Should Do to Grow Monthly Traffic on a Tech Blog",
 "image": [
 "https://example.com/img/eyecatch.jpg"
 ],
 "datePublished": "2026-09-14T10:00:00+09:00",
 "author": {
 "@type": "Person",
 "name": "Kenji",
 "url": "https://example.com/about/"
 },
 "publisher": {
 "@type": "Organization",
 "name": "Kenji's Tech Blog",
 "logo": {
 "@type": "ImageObject",
 "url": "https://example.com/img/logo.png"
 }
 }
}
</script>

1.3 Semantic HTML and Document Structure Optimization

Proper nesting of headings (h1 to h6) is fundamental, but tech blogs require accurate use of HTML5 semantic tags like article, section, aside, and nav. Also, appropriately distinguishing <code> and <pre> for source code, <kbd> for keyboard inputs, and <var> for variables provides machine-readable HTML. This is also a highly effective measure for AI content indexing (LLM training data collection and RAG systems).

2. The Psychology of Search Intent and Keyword Strategy

To maximize incoming traffic from search engines (organic traffic), you need to accurately decipher the search intent—“why did the user search for that keyword?” Search intent in the tech field can be broadly classified into two types.

2.1 “Troubleshooting Type” vs. “Systematic Learning & Review Type”

Troubleshooting Intent
- Example search keywords: Docker "no space left on device" solution, Python IndexError list index out of range cause
- Psychology: Blocked by an error during development, looking for a quick fix command or code snippet right now.
- Strategy: Present the “conclusion (code or command to solve the issue)” at the very beginning of the article (above the fold). Place the background and detailed mechanism explanations after that, first satisfying the user’s desire to “fix it immediately.” This helps reduce the bounce rate.
Systematic Learning & Review Intent
- Example search keywords: React vs Vue 2026 comparison, Rust asynchronous processing tutorial, GCP network architecture design
- Psychology: Wants to select a new tech stack or deepen their understanding from the basics, and is ready to take time to read.
- Strategy: Enrich the Table of Contents (TOC) and heavily use diagrams and architecture charts (Mermaid, etc.). Objectively compare pros and cons and include use cases of how it can be applied in actual work, which can increase time spent on the page.

2.2 Exponential Decay Model of Traffic and Long-Tail Strategy

Traffic for technical articles tends to form a spike (surge) right after publication due to buzz on SNS, etc., and then decreases exponentially. This traffic $V(t)$ can be approximated by the following mathematical model:

$$ V(t) = V_0 e^{-\lambda t} + C $$

Where:

$V(t)$: Traffic volume at time $t$
$V_0$: Initial traffic spike volume due to SNS buzz immediately after publication
$\lambda$: Decay constant associated with content obsolescence and forgetting on SNS (depends on the speed of technological trend changes)
$C$: Stable organic search inflow from search engines (baseline traffic)

The key to growing traffic over the long term is not to aim for a temporary buzz ($V_0$), but how to make the constant term $C$ (sustained inflow from search engines) as large as possible. By covering a massive amount of “long-tail keywords”—such as specific niche errors or integration methods between specific tools—that have low search volume but no competition, you can grow the total sum of $C$ into something enormous.

3. Data-Driven Content Analysis Using Google Search Console API

To build a stable traffic foundation $C$, it is necessary to utilize Google Search Console (GSC) data to objectively analyze “how Google evaluates your site.” However, clicking around the GSC Web UI has its limits. If you are an engineer, automate the analysis using the GSC API and Python.

3.1 Automation Approach with GSC API and Python

Create a script that automatically detects “wasteful articles” where the search ranking drops over time (Decaying Content), or where impressions are high but the Click-Through Rate (CTR) is abnormally low. This uses google-api-python-client and pandas.

3.2 Python Implementation Code: Auto-Extracting Content with Decreased CTR

Below is an example of a script that fetches search performance data for the past 30 days from the API and extracts a “recommended list of keywords and article URLs with great room for improvement in title or description” where impressions are 1000 or more and CTR is 2% or less.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


import pandas as pd
from google.oauth2 import service_account
from googleapiclient.discovery import build
import datetime

# 1. Authentication and API service construction
KEY_FILE_LOCATION = 'path/to/your-service-account-key.json'
SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']
SITE_URL = 'https://your-tech-blog.com/'

credentials = service_account.Credentials.from_service_account_file(
 KEY_FILE_LOCATION, scopes=SCOPES)
webmasters_service = build('searchconsole', 'v1', credentials=credentials)

# 2. Calculation of request period (past 30 days)
today = datetime.date.today()
end_date = (today - datetime.timedelta(days=2)).strftime('%Y-%m-%d')
start_date = (today - datetime.timedelta(days=32)).strftime('%Y-%m-%d')

# 3. Execution of API request
request = {
 'startDate': start_date,
 'endDate': end_date,
 'dimensions': ['query', 'page'],
 'rowLimit': 5000
}

response = webmasters_service.searchanalytics().query(
 siteUrl=SITE_URL, body=request).execute()

# 4. Data processing and filtering using Pandas DataFrame
if 'rows' in response:
 rows = response['rows']
 data = []
 for row in rows:
 data.append({
 'Query': row['keys'][0],
 'URL': row['keys'][1],
 'Clicks': row['clicks'],
 'Impressions': row['impressions'],
 'CTR': row['ctr'],
 'Position': row['position']
 })

 df = pd.DataFrame(data)

 # Filtering condition: Impressions >= 1000 & CTR < 2%
 target_df = df[(df['Impressions'] >= 1000) & (df['CTR'] < 0.02)]

 # Sort in ascending order by position (prioritize high ranking but unclicked)
 target_df = target_df.sort_values(by='Position', ascending=True)

 print("[Recommended List for Title/Meta Description Improvement]")
 print(target_df.head(10))

 # Export to CSV if necessary, etc.
 # target_df.to_csv('improve_candidates.csv', index=False)
else:
 print("No data found.")

By running this script as a cron job or a GitHub Actions scheduled job, you can continuously make data-driven decisions on “which article titles to rewrite.” It’s important to rely on data rather than intuition for continuous improvement (Continuous Content Improvement).

4. Article Lifecycle Management and Rewrite Strategy

Publishing a technical article is not the end. As technology evolves (framework version updates, API deprecations, etc.), content quickly becomes obsolete. Continuing to provide outdated information not only damages the blog’s credibility but also negatively affects SEO.

4.1 Content Lifecycle Management (Gantt Chart)

The ideal content operation lifecycle is shown in a Mermaid Gantt chart.

gantt
title Data-Driven Content Lifecycle Management
dateFormat YYYY-MM-DD
axisFormat %m/%d
section "Phase 1: Planning & Writing"
"Search Keyword & Trend Analysis" :a1, 2026-09-01, 3d
"Draft & Code Verification" :a2, after a1, 5d
"Revision & Proofreading" :a3, after a2, 2d
section "Phase 2: Publishing & Promo"
"Deployment via CI/CD Pipeline" :p1, 2026-09-11, 1d
"Automated SNS Delivery (X, LinkedIn, RSS)" :p2, 2026-09-11, 1d
"Ripple Effect to Bookmarks, etc." :p3, after p2, 3d
section "Phase 3: Observation & Analysis"
"GSC Data Accumulation Period" :m1, 2026-09-14, 28d
"Performance Eval via Python API":m2, after m1, 2d
section "Phase 4: Improvement (Rewrite)"
"Title Fix for Low CTR Articles" :r1, after m2, 3d
"Code Update to Latest Version":r2, after r1, 4d

Treating article creation like a software development project and incorporating the post-release operation/maintenance (rewrite) phase into your plan is the secret to maintaining and improving traffic.

4.2 Mathematical Model of Content Creation ROI (Return on Investment)

Since engineers spend valuable time writing articles, they should be aware of the Return on Investment (ROI). The ROI for a blog can be formulated as follows:

$$ ROI = \frac{\sum_{t=1}^{T} \left( Rev_{ad}(t) + Val_{brand}(t) + Val_{skill}(t) \right) - Cost_{time}}{\text{Cost}_{time}} \times 100 \ (\%) $$

$T$: Effective lifespan of the article (time until it becomes obsolete)
$Rev_{ad}(t)$: Direct revenue from ad earnings, affiliate revenue, and sponsorships
$Val_{brand}(t)$: Monetary equivalent of the positive impact on career due to demonstrating technical skills (e.g., increased offer amount when changing jobs, speaking requests)
$Val_{skill}(t)$: Value of personal skill improvement through learning and research done to write the article
$Cost_{time}$: Time spent writing the article, creating diagrams, and verifying code (converted to personal hourly rate)

The great thing about tech blogs is that even if $Rev_{ad}$ is small, $Val_{brand}$ and $Val_{skill}$ tend to be extremely large. In particular, high-quality technical explanations serve directly as a portfolio, wielding immense power in job hunting or securing side jobs.

5. Distribution via GitHub Actions and External Automation Tool Integration

After creating content, the challenge becomes how to efficiently deliver it to the target audience (distribution). Manually posting links to each SNS every time is inefficient and un-engineer-like.

We will build an architecture that fully automates everything from building, deploying, and notifying multiple platforms the moment a Markdown file is merged into the main branch of a GitHub repository.

flowchart TD
A["Developer (Git Push)"] --> B["GitHub Repository"]
B -->|Webhook| C["GitHub Actions (CI/CD)"]
C -->|Build| D["Static Site Generator (Hugo/Gatsby)"]
D -->|Deploy| E["Hosting (Vercel / Cloudflare Pages)"]
D -->|Generate| F["RSS Feed (index.xml)"]
F -->|Polled by| G["Zapier / IFTTT / Make"]
G -->|API Call| H["X (Twitter) Auto Post"]
G -->|API Call| I["LinkedIn Article Post"]
G -->|API Call| J["Discord / Slack Community Webhook"]
C -->|Actions Script| K["Qiita / Zenn Cross-Post API"]

5.2 Key Points for Building an Automation Pipeline

Build and Deploy with GitHub Actions If using a static site generator, automate the HTML generation and deployment to the hosting provider (Vercel, Netlify, Cloudflare Pages, etc.) using GitHub Actions. At this time, it is also effective to incorporate an image optimization process (such as auto-conversion to WebP) into the build pipeline as a Core Web Vitals countermeasure mentioned earlier.
SNS Integration with RSS Triggers Using Zapier/IFTTT The site generator creates the latest RSS feed (XML) during the build. Feed this into an iPaaS like Zapier or Make (formerly Integromat) to build a workflow such as “When a new item is added to RSS, post the title and URL to X (Twitter) and LinkedIn.” With this, notifications to followers are automatically sent the moment an article is published.
Cross-Posting to Qiita/Zenn (Using Canonical Tags) While the domain authority of your company or personal blog is still weak, borrowing the visitor attraction power of technical platforms like Qiita or Zenn is one strategy. However, simple copy-pasting carries the risk of SEO penalties for duplicate content. This issue can be resolved by setting a Canonical tag in the metadata of the Qiita or Zenn article, pointing to the original article URL on your own blog. By writing a script that hits various platform APIs from GitHub Actions to automatically generate articles from Markdown, you can fully automate multi-channel delivery.

Conclusion: Turning the Cycle of Continuous Improvement

To dramatically increase monthly traffic on a tech blog, the engineering approaches introduced this time are indispensable in addition to the act of “writing.”

Building a robust HTML and site architecture with SEO in mind
Article design that understands the user’s search intent (troubleshooting vs. systematic learning)
Data analysis utilizing the Google Search Console API and Python
Content lifecycle management and rewriting with ROI in mind
Complete automation of distribution through CI/CD and Zapier integration

If you can assemble these as a system, your tech blog will become the strongest asset to powerfully boost your own career. Engineers struggling with stagnant traffic should definitely start “blog growth hacking” today. The programming skills and architecture design abilities cultivated in development work will undoubtedly be your greatest weapons in blog management as well.

SEO on kenji.blog

A Strategy for Rewriting Past Tech Articles Using Google Search Console

1. Introduction: The Importance of Rewriting in Tech Blogs and the Data-Driven Approach

2. Gap Analysis Between Expected CTR and Actual CTR (Introduction of a Mathematical Model)

3. Automatic Extraction of Search Performance Data Using GSC API (Python)

4. Filtering Technical Keywords Using Regular Expressions (Regex)

5. Integrating GA4 and GSC Data with BigQuery/Pandas

6. Content Gap Analysis Using NLP and TF-IDF

7. Data Pipelines and Continuous Improvement Cycle

8. Conclusion and Future Outlook

Hugo Blog SEO: Frontmatter Settings to Dramatically Increase Traffic

1. Mathematical Background of SEO and Traffic

2. Hugo’s Build Process and the Role of Frontmatter

3. Basic Metadata Settings: Title, Description, Canonical URL

3.1. Frontmatter Setting Example

3.2. Implementation of layouts/partials/head.html

4. OGP and Twitter Cards: Maximizing CTR on Social Media

4.1. Issues with Built-in Templates

4.2. Specifying Images in Frontmatter

4.3. Custom Implementation Code for OGP and Twitter Cards

5. Implementation of Structured Data (JSON-LD)

5.1. Structure of JSON-LD

5.2. JSON-LD Generation in Hugo Templates

6. Advanced Techniques for Utilizing Frontmatter

6.1. Redirect Processing via Aliases

6.2. Article Expiration Dates and Scheduling

7. Site Performance and Core Web Vitals

8. Conclusion

Indie App Promotion Strategy: How to Leverage a Tech Blog

1. SEO Strategy to Turn Your Tech Blog into a “Traffic Generator”

1.1 Optimization of Open Graph Protocol (OGP)

1.2 Implementation of Structured Data Using JSON-LD

2. Funnel Design from Tutorial to Conversion

2.1 Visualization of the User Journey

2.2 Mathematical Model of Conversion Rate

3. Implementation of Edge A/B Testing Using Vercel Edge Config

3.1 Edge A/B Testing Architecture

3.2 Middleware Implementation Code

4. Data-Driven Growth Hacking: Implementation of GA4 and PostHog

4.1 Event Tracking with Google Analytics 4 (GA4)

4.2 Product Analytics using PostHog

4.3 Evaluation of Unit Economics (LTV and CAC)

5. Conclusion

What Engineers Should Do to Grow Monthly Traffic on a Tech Blog

Introduction: Tech Blog Growth Hacking Only Engineers Can Do

1. SEO Architecture for Engineer Tech Blogs

1.1 Core Web Vitals Optimization

1.2 Implementation of Structured Data (JSON-LD)

1.3 Semantic HTML and Document Structure Optimization

2. The Psychology of Search Intent and Keyword Strategy

2.1 “Troubleshooting Type” vs. “Systematic Learning & Review Type”

2.2 Exponential Decay Model of Traffic and Long-Tail Strategy

3. Data-Driven Content Analysis Using Google Search Console API

3.1 Automation Approach with GSC API and Python

3.2 Python Implementation Code: Auto-Extracting Content with Decreased CTR

4. Article Lifecycle Management and Rewrite Strategy

4.1 Content Lifecycle Management (Gantt Chart)

4.2 Mathematical Model of Content Creation ROI (Return on Investment)

5. Distribution via GitHub Actions and External Automation Tool Integration

5.1 Social Media Sharing Automation Architecture

5.2 Key Points for Building an Automation Pipeline

Conclusion: Turning the Cycle of Continuous Improvement

3.2. Implementation of `layouts/partials/head.html`