Google Search Console 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.

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.