Building an Automated Bilingual Blog System with Obsidian: Going Global in Two Languages

Introduction: Why I Built This System

For 9 years since joining the company, I've worked as an engineer in the AD/ADAS field. While I accumulated expertise, I felt it was a career risk that my work wasn't visible outside the company and had zero recognition in the global market.

Expertise might as well not exist if it isn't visible.

Then I realized: Nothing will change unless I put myself out there.

However, I faced the following challenges:

• Lack of time: With a full-time job, I couldn't dedicate 10 hours per week to blogging
• Difficulty maintaining: Manual posting is cumbersome and leads to quick abandonment
• Global reach: Japanese-only content has limitations; English content is also necessary

In this article, I'll introduce the bilingual automated blog posting system I built that costs only $10.18 per year to operate.

What This System Can Achieve

Key Features

Write article (Obsidian) → One button → Distribute worldwide

Specifically:

• Write in Japanese → Auto-generate English version via AI translation
• Automatic SEO optimization
• Auto-publish to custom domain blog
• Auto-generate LinkedIn posts
• Prepare for distribution to Medium, Dev.to, etc.
• Automatic Google Analytics tracking

Time required: Within 5 minutes (excluding article writing)
Annual cost: $10.18 (domain fee only)

Challenges Solved

Before (Pre-System Build)

3 hours to publish one article:

• Writing in Obsidian: 2 hours
• Manual HTML conversion: 20 minutes
• Image optimization: 15 minutes
• SEO configuration: 15 minutes
• GitHub push: 10 minutes
• Deploy verification: 10 minutes
• LinkedIn post creation: 30 minutes
• English translation: 1 hour (outsourced or self-translated)

Total: 4-5 hours
→ Impossible to publish 2 articles per week
→ Gave up

After (Post-System Build)

1 hour to publish one article:

• Writing in Obsidian: 50 minutes
• Run automation script: 5 minutes → AI translation → SEO optimization → Image optimization → Automatic GitHub push → Automatic Cloudflare deployment → Auto-generate LinkedIn post
• Final check: 5 minutes

Total: 1 hour
→ Possible to publish 2 articles per week
→ Sustainable

System Architecture

Overall System Diagram

graph TD subgraph Writing["Writing Environment (Obsidian)"] A[Write Articles in Markdown] --> B[Core Vault] B --> C[Blog Vault] end subgraph Automation["Automation Layer (Python + AI)"] C --> D[AI Translation<br/>Claude API] D --> E[SEO Optimization<br/>Auto Description Generation] E --> F[Quality Check<br/>AI Analysis] F --> G[Hugo Static Site Generation] end subgraph Deploy["Deployment & Delivery"] G --> H[GitHub Repository] H --> I[Cloudflare Pages<br/>Auto Build] I --> J[Custom Domain Blog<br/>CDN Delivery] end subgraph SNS["Social Media Distribution"] G --> K[LinkedIn Post Generation] K --> L[LinkedIn API Posting] G --> M[Medium/Dev.to<br/>Distribution Prep] end subgraph Analytics["Analytics"] J --> N[Google Analytics GA4] end J --> O((Readers)) L --> O M --> O style A fill:#DCE7FF,stroke:#333 style D fill:#FFE6CC,stroke:#333 style E fill:#FFE6CC,stroke:#333 style F fill:#FFE6CC,stroke:#333 style I fill:#ADD8E6,stroke:#333 style J fill:#90EE90,stroke:#333 style O fill:#FFB6C1,stroke:#333 

Technology Stack

Total Annual Cost: $10.18 + API usage $60-120 = $70.18-130.18 (approximately ¥10,000)

Core Implementation: 5 Stages

Stage 1: Draft

Purpose: Review and modify articles locally

draft.bat # Or include English translation simultaneously draft_translate.bat 

Process:

1. Retrieve articles from Obsidian (Core Vault)
2. Automatically convert to Hugo format
3. Save with draft: true (private)
4. Auto-launch Hugo server
5. Open http://localhost:1313 in browser

At this stage:

• No GitHub push
• Multiple revisions and previews possible
• Completely local process

AI Translation Feature:

# translate_article.py (excerpt) def translate_with_claude(japanese_text): """Translate Japanese to English using Claude API""" prompt = f""" Please translate the following technical article to English: - Use appropriate technical terms - Natural, readable English - Preserve Markdown formatting {japanese_text} """ # Call Claude API  response = call_claude_api(prompt) return response 

Stage 2: Quality Check

Purpose: Perform AI-based article quality analysis

check.bat 

Check Items:

• Detection of omitted subjects (Japanese-specific issue)
• Detection of logical gaps
• Abstract-to-concrete correspondence
• Detection of ambiguous expressions
• Accuracy of technical terms
• SEO improvement suggestions

Output Example:

# Quality Report ## Subject Omission (3 places) - Line 45: "Built the system" → Who did? Suggestion: "I built the system" ## Logic Gaps (2 locations) - Line 78-82: Gap between Step 2 and Step 3 Suggestion: Add intermediate steps ## Ambiguous Expressions (5 locations) - Line 92: "quite fast" → what are the specific numbers? Suggestion: "3 times faster (7h → 2h)" ## Overall Rating: 85/100 Can improve to: 90/100 

Stage 3: Pre-Publish Optimization

Purpose: Perform SEO optimization and Description auto-generation

# Automatically executed when publish.bat runs 

Execution Details:

1. Description Auto-generation (Claude API)

def generate_description(article_text): """Generate SEO-optimized summary automatically""" prompt = f""" Please generate an SEO-optimized summary from the following article. Requirements: - 120-160 characters - Naturally include keywords - Capture reader interest - Convey article core message {article_text} """ description = call_claude_api(prompt) return description 

2. Automated SEO Check

seo_checks = { 'title_length': Within 60 characters?, 'h1_exists': Has H1 tag?, 'description': Between 120-160 characters?, 'images': Has alt attributes?, 'word_count': Minimum 1,500 words?, 'tags': Has 3-5 tags?, 'internal_links': Has internal links? } 

3. H1 Handling (Important)

Issue: Hugo theme outputs title as H1 → Duplicates with H1 in Markdown → Bad for SEO Solution: 1. Comment out H1 in Markdown 2. Hide with CSS 3. Keep in HTML (for SEO) 

Stage 4: Publish

Purpose: Actually publish the article

publish.bat 

Execution Flow:

def publish_workflow(): # 1. Generate description  description = generate_description(article) # 2. SEO automatic check  seo_result = check_seo(article) if not seo_result.passed: print("SEO issues found:", seo_result.issues) if not confirm("Publish anyway?"): return # 3. Convert to Hugo format (draft: false)  convert_to_hugo(article, draft=False) # 4. Save Japanese and English versions  save_bilingual_articles(article_ja, article_en) # 5. Automatic Git push  git_push_with_message(f"Publish: {article.title}") # 6. Generate LinkedIn posts  generate_linkedin_posts(article) print("✅ Publishing complete!") print(f"Japanese: https://takuyaniioka.com/ja/posts/{slug}/") print(f"English: https://takuyaniioka.com/posts/{slug}/") 

Post-publish Auto-deployment:

GitHub Push ↓ (Webhook) Cloudflare Pages Detection ↓ Hugo Auto-build (about 30 seconds) ↓ CDN Distribution ↓ Blog Published 

Stage 5: Social Media (LinkedIn)

Purpose: Automatically generate LinkedIn posts from articles

linkedin_post.bat 

This system can automatically generate LinkedIn posts from articles. We plan to modify the design in the future to allow manual editing and posting as needed.

Stage 6: Analytics

Google Analytics GA4 Integration:

# BlogVault/config.toml [params] googleAnalytics = "G-XXXXXXXXXX" 

Tracking Data:

• Real-time access
• Traffic sources (LinkedIn, Medium, Google etc.)
• Popular article rankings
• Device and region statistics
• Time on site and bounce rate

Design Philosophy: Why This Architecture?

1. Obsidian-Centric Approach

Reasons:

• Second Brain: Core of my intellectual productivity
• Unified Management: Articles and notes, all managed in Obsidian
• Prevent Thought Fragmentation: Information is not scattered

Structure:

Obsidian/ ├── Core Vault/ # Private & intellectual production │ ├── Daily Notes/ │ ├── Projects/ │ └── Articles/ # Article drafts │ └── Blog Vault/ # Public & blog-specific ├── content/ ├── static/ └── config.toml 

Reasons for Separation:

• Core Vault is private (personal notes & confidential information)
• Blog Vault is public (pushed to GitHub)
• Maintains clear boundaries

2. AI Utilization Philosophy

AI is "Augmentation" not "Replacement"

[Wrong Usage] Let AI write everything → Zero originality → Zero value [Correct Usage] Human: Write core insights & experiences AI: Automate translation, SEO, quality checks → Humans focus on intellectual production → AI handles repetitive tasks 

Concrete Examples:

• ✅ AI Translation: Think deeply in Japanese, AI translates to English
• ✅ SEO Optimization: AI auto-generates descriptions
• ✅ Quality Check: AI provides objective review
• ❌ Article Writing: Written by humans (AI assists only)

3. Staged Workflow

Why Split into 5 Stages:

Reason 1: Safety

• Gradual verification instead of immediate publication
• Detect and fix issues at each stage

Reason 2: Flexibility

• Can pause at any point
• Can resume from any stage

Reason 3: Debuggability

• Clear identification of where problems occur
• Logs provide immediate clarity

Implementation Details: Core Features

Feature 1: Article Format Conversion

Challenge:

• Obsidian format (EvolutionVault)
• Hugo format (BlogVault)
• Different formats

Solution:

def convert_evolution_to_hugo_format(source_file, draft_mode=True): """EvolutionVault format → Hugo format""" # 1. Parse YAML frontmatter  with open(source_file, 'r', encoding='utf-8') as f: content = f.read() # Separate frontmatter and body  if content.startswith('---'): parts = content.split('---', 2) frontmatter = parts[1] body = parts[2] if len(parts) > 2 else "" # 2. Convert for Hugo  hugo_frontmatter = convert_frontmatter(frontmatter) hugo_frontmatter['draft'] = draft_mode # 3. Save  output_path = get_hugo_path(source_file) save_hugo_file(output_path, hugo_frontmatter, body) 

Feature 2: Automated SEO Optimization

Challenge:

• Manual description writing is time-consuming
• Easy to miss SEO checks

Solution:

def optimize_seo(article): """Automated SEO optimization""" # 1. Auto-generate description (Claude API)  description = generate_description_with_ai(article.content) article.description = description # 2. SEO checklist  checks = [ check_title_length(article.title), check_description_length(article.description), check_h1_tag(article.content), check_image_alt_tags(article.content), check_word_count(article.content), check_tags(article.tags), check_internal_links(article.content) ] # 3. Warning if issues found  issues = [c for c in checks if not c.passed] if issues: print("⚠️ SEO issues:") for issue in issues: print(f" - {issue.message}") return article 

Feature 3: Bilingual Support

Challenge:

• Managing Japanese and English separately is complex
• Separate URLs needed

Solution:

Utilizing Hugo's multilingual features: Japanese: https://takuyaniioka.com/ja/posts/article-slug/ English: https://takuyaniioka.com/posts/article-slug/ Automatic switching: - Detects browser language settings - Japanese browser → /ja/ - English browser → / 

Implementation:

# config.toml [languages] [languages.en] languageName = "English" weight = 1 contentDir = "content" [languages.ja] languageName = "日本語" weight = 2 contentDir = "content" [params] defaultContentLanguage = "en" defaultContentLanguageInSubdir = false 

Results: What This System Delivered

Quantitative Results

How to Build This System

Construction Steps (Overview)

Step 1: Environment Setup (1 hour)

1. Install Obsidian
2. Install Hugo
3. Install Git
4. Install Python
5. Create GitHub account
6. Create Cloudflare account

Step 2: Domain Acquisition (15 minutes)

1. Get custom domain from NameCheap ($10.18/year)
2. Configure DNS in Cloudflare
3. Set up email forwarding (optional)

Step 3: Hugo Setup (30 minutes)

1. Create Hugo site
2. Select theme (Hugo Clarity recommended)
3. Configure config.toml
4. Set up bilingual settings

Step 4: Cloudflare Pages Setup (15 minutes)

1. Create GitHub repository
2. Link to Cloudflare Pages
3. Configure build settings (Hugo)
4. Set up custom domain

Step 5: Automation Script Setup (1 hour)

1. Install Python dependencies
2. Deploy automation scripts
3. Create .bat files
4. Configure Claude API
5. Run tests

Step 6: First Post Publication (30 minutes)

1. Write article in Obsidian
2. Run draft.bat
3. Check preview
4. Run publish.bat
5. Complete publication

Total time required: About 4 hours

Summary: The Essence of This System

• Time reduction: 5 hours → 1 hour
• Cost reduction: 95% reduction
• Multilingual support: Japanese-English automatic
• Social media deployment: Automated

Resources

Reference Links

• Hugo Official Documentation
• Cloudflare Pages
• Claude API
• LinkedIn API
• Obsidian

GitHub Repository

While it's not currently public, I'm open to considering making it public upon request. The content is expected to include the following structure:

• Automation scripts
• Setup guide
• Troubleshooting
• FAQ