モジュール R: 収益エンジン

STREETS 開発者収入コース — 有料モジュール 第5〜8週 | 全8レッスン | 成果物: 最初の収益エンジン + エンジン #2 の計画

「機能を出荷するコードではなく、収入を生むシステムを構築せよ。」

モジュール S でインフラを構築した。モジュール T で競合が簡単にコピーできないものを手に入れた。いよいよ、それらすべてをお金に変える時だ。

このモジュールはコース内で最も長い。最も重要だからだ。8つの収益エンジン。スキル、ハードウェア、時間を収入に変える8つの異なる方法。それぞれが実際のコード、実際の価格設定、実際のプラットフォーム、実際の計算を含む完全なプレイブックだ。

8つ全部を構築するわけではない。2つを選ぶのだ。

1+1 戦略:

• エンジン 1: 最初の1ドルへの最速ルート。第5〜6週で構築する。
• エンジン 2: あなたの状況に最も適したスケーラブルなエンジン。第7〜8週で計画し、モジュール E で構築を開始する。

なぜ2つか？収入源が1つだけでは脆い。プラットフォームが規約を変更する、クライアントがいなくなる、市場が変わる — するとゼロに戻る。異なる顧客タイプに異なるチャネルでサービスを提供する2つのエンジンがあれば、レジリエンスが生まれる。そしてエンジン 1 で構築するスキルは、ほぼ必ずエンジン 2 を加速させる。

このモジュールが終わる頃には、以下を手に入れている:

• エンジン 1 からの収益（または数日以内に収益を生むインフラ）
• エンジン 2 の詳細な構築計画
• どのエンジンが自分のスキル、時間、リスク許容度に合っているかの明確な理解
• 実際にデプロイされたコード — 計画だけではなく

理論はなし。「いつか」もなし。構築を始めよう。

レッスン 1: デジタルプロダクト

「合法的にお金を刷るのに最も近い方法。」

最初の1ドルまで: 1〜2週間 継続的な時間コミットメント: 週2〜4時間（サポート、アップデート、マーケティング） 利益率: 95%以上（制作後のコストはほぼゼロ）

なぜデジタルプロダクトが最初なのか

デジタルプロダクトは、開発者にとって最も利益率が高く、最もリスクの低い収益エンジンだ。一度作れば、永遠に売れる。管理するクライアントもいない。時間単位の請求もない。スコープクリープもない。会議もない。

計算はシンプルだ:

• テンプレートやスターターキットの構築に20〜40時間
• 価格は $49
• 初月に10部販売: $490
• その後毎月5部販売: $245/月のパッシブ収入
• 制作後のコスト: $0

その $245/月はエキサイティングに聞こえないかもしれないが、継続的な時間は一切不要だ。プロダクトを3つ重ねれば $735/月が寝ている間に入ってくる。10個重ねれば、ジュニア開発者の給料を代替できる。

何が売れるか

作れるもの全てが売れるわけではない。開発者が実際にお金を払うもの、そして現在販売されているプロダクトの実際の価格帯を示す:

スターターキットとボイラープレート

コンポーネントライブラリと UI キット

ドキュメントと設定

本音: 最もよく売れるプロダクトは、具体的で即座の痛みを解決するものだ。「40時間のセットアップを節約」は「新しいフレームワークを学ぶ」を毎回上回る。開発者は今まさに抱えている問題への解決策を買う。いつか抱えるかもしれない問題ではない。

販売場所

Gumroad — 最もシンプルな選択肢。30分でプロダクトページをセットアップし、すぐに販売開始。各販売の10%が手数料。月額料金なし。

• 最適: 最初のプロダクト。需要のテスト。$100未満のシンプルなプロダクト。
• デメリット: カスタマイズが限定的。無料プランにはアフィリエイトプログラムが組み込まれていない。

Lemon Squeezy — Merchant of Record（販売者代行）なので、グローバルな消費税、VAT、GST を代行処理してくれる。取引ごとに 5% + $0.50。

• 最適: 海外販売。$50以上のプロダクト。サブスクリプションプロダクト。
• メリット: VAT の登録が不要。すべてを代行処理してくれる。
• デメリット: Gumroad よりセットアップがやや複雑。

自分のサイト — 最大のコントロールとマージン。支払いに Stripe Checkout を使い、Vercel/Netlify で無料ホスティング。

• 最適: トラフィックがある場合。$100以上のプロダクト。ブランド構築。
• メリット: プラットフォーム手数料 0%（Stripe の 2.9% + $0.30 のみ）。
• デメリット: 税務コンプライアンスは自分で対応（または Stripe Tax を使用）。

よくある間違い: 売るプロダクトが1つもない段階で、カスタムストアフロントの構築に2週間費やすこと。最初のプロダクトには Gumroad か Lemon Squeezy を使おう。需要を検証し、手間をかける正当性のある収益が出てから自分のサイトに移行すればいい。

48時間でアイデアから出品まで

正確な手順はこうだ。タイマーをセットしよう。48時間だ。

0〜2時間目: プロダクトを選ぶ

モジュール S の主権的スタックドキュメントを見よう。あなたの主要スキルは何か？毎日使っているフレームワークは何か？最近やったセットアップで、やたらと時間がかかったものは何か？

最初のプロダクトに最適なのは、すでに自分のために作ったものだ。3日かかった Tauri アプリのスキャフォールディング？それがプロダクトだ。チームのために設定した CI/CD パイプライン？それがプロダクトだ。週末をかけて正しく動かした Docker のセットアップ？プロダクトだ。

2〜16時間目: プロダクトを構築する

プロダクト自体はクリーンで、よくドキュメント化されていて、特定の問題を解決するものであるべきだ。最低限必要なもの:

my-product/
  README.md           # インストール、使い方、含まれるもの
  LICENSE             # ライセンス（下記参照）
  CHANGELOG.md        # バージョン履歴
  src/                # 実際のプロダクト
  docs/               # 必要に応じた追加ドキュメント
  examples/           # 動作するサンプル
  .env.example        # 該当する場合

ドキュメントはプロダクトの半分だ。 よくドキュメント化されたテンプレートは、ドキュメントのないより優れたテンプレートを毎回上回る。ローカル LLM を使ってドキュメントの下書きを作成しよう（まだセットアップしていなければ、モジュール S から Ollama をセットアップすること）:

# コードベースから初期ドキュメントを生成
ollama run llama3.1:8b "Given this project structure and these key files,
write a comprehensive README.md that covers: installation, quick start,
project structure explanation, configuration options, and common
customizations. Be specific and include real commands.

Project structure:
$(find . -type f -not -path './.git/*' | head -50)

Key file (package.json):
$(cat package.json)

Key file (src/main.tsx):
$(cat src/main.tsx | head -80)"

その後、出力を編集する。LLM がドキュメントの70%を提供してくれる。あなたの専門知識が残りの30% — ニュアンス、注意点、「なぜこのアプローチを選んだか」というコンテキスト — を提供し、ドキュメントを本当に役立つものにする。

16〜20時間目: 出品を作成する

Lemon Squeezy ストアをセットアップする。チェックアウト統合は簡単だ — プロダクトを作成し、配信用の Webhook をセットアップすれば公開できる。コード例付きの決済プラットフォーム設定の完全なウォークスルーは、モジュール E のレッスン 1 を参照。

20〜24時間目: セールスページを書く

セールスページに必要なのは正確に5つのセクション:

1. 見出し: プロダクトが何をし、誰のためのものか。「本番環境対応 Tauri 2.0 スターターキット — 40時間のボイラープレートをスキップ。」
2. ペインポイント: 解決する問題は何か。「新しい Tauri アプリの認証、データベース、自動アップデート、CI/CD のセットアップには何日もかかる。このスターターは git clone 一発ですべてを提供する。」
3. 含まれるもの: パッケージに含まれるすべてのバレットリスト。具体的に。「14のプリビルトコンポーネント、Stripe 課金統合、マイグレーション付き SQLite、クロスプラットフォームビルド用 GitHub Actions。」
4. ソーシャルプルーフ: あれば。GitHub スター、推薦コメント、または「[あなた]が構築 — [X]年間の本番 [フレームワーク] アプリ構築経験。」
5. 行動喚起: ボタン1つ。価格1つ。「$49 — 今すぐアクセスを取得。」

ローカル LLM を使ってコピーの下書きを作成し、自分の声で書き直す。

24〜48時間目: ソフトローンチ

以下の場所に投稿する（プロダクトに関連するものを選ぶ）:

• Twitter/X: 何を作ったか、なぜ作ったかを説明するスレッド。スクリーンショットか GIF を含める。
• Reddit: 関連するサブレディットに投稿（r/reactjs、r/rust、r/webdev など）。営業的にならないこと。プロダクトを見せ、解決する問題を説明し、リンクを貼る。
• Hacker News: 「Show HN: [プロダクト名] — [一行の説明]」 事実のみを述べる。
• Dev.to / Hashnode: プロダクトを使ったチュートリアルを書く。さりげなく、価値のあるプロモーション。
• 関連する Discord サーバー: 適切なチャンネルで共有。ほとんどのフレームワーク Discord サーバーには #showcase や #projects チャンネルがある。

デジタルプロダクトのライセンス

ライセンスが必要だ。選択肢は以下:

パーソナルライセンス ($49): 1人、無制限の個人・商用プロジェクト。再配布・転売は不可。

チームライセンス ($149): 同じチームの最大10人の開発者。再配布に関する制限は同じ。

拡張ライセンス ($299): エンドユーザーに販売されるプロダクトに使用可能（例: テンプレートを使ってクライアントに販売する SaaS を構築する場合）。

プロダクトに LICENSE ファイルを含める:

[Product Name] License Agreement
Copyright (c) [Year] [Your Name/Company]

Personal License — Single Developer

This license grants the purchaser the right to:
- Use this product in unlimited personal and commercial projects
- Modify the source code for their own use

This license prohibits:
- Redistribution of the source code (modified or unmodified)
- Sharing access with others who have not purchased a license
- Reselling the product or creating derivative products for sale

For team or extended licenses, visit [your-url].

収益の計算

$49 のプロダクトで実際の計算をしてみよう:

プラットフォーム手数料 (Lemon Squeezy, 5% + $0.50):  -$2.95
決済処理（込み）:                                      $0.00
1販売あたりの収益:                                     $46.05

$500/月を達成するには:  11販売/月（1日1未満）
$1,000/月を達成するには: 22販売/月（1日1未満）
$2,000/月を達成するには: 44販売/月（1日約1.5）

これらは、アクティブなニッチでうまくポジショニングされたプロダクトにとって現実的な数字だ。

現実のベンチマーク:

• ShipFast (Marc Lou): Next.js ボイラープレート、価格約 $199-249。最初の4ヶ月で $528K を生み出した。Marc Lou は10個のデジタルプロダクトを運営し、合計で月約 $83K を生み出している。(出典: starterstory.com/marc-lou-shipfast)
• Tailwind UI (Adam Wathan): UI コンポーネントライブラリ。最初の3日間で $500K、最初の2年間で $4M を超えた。しかし、2025年後半には AI 生成の UI が需要を食い始め、収益は前年比約80%減少した — 成功したプロダクトでも進化が必要であることを示すリマインダーだ。(出典: adamwathan.me, aibase.com)

あれほどの数字は不要だ。11販売が必要なだけだ。

あなたの番

1. プロダクトを特定する（30分）: 主権的スタックドキュメントを見よう。20時間以上かけて自分のために構築したものは何か？それが最初のプロダクトだ。書き出す: プロダクト名、解決する問題、ターゲットバイヤー、価格。

2. 最小限のプロダクトを作成する（8〜16時間）: 既存の成果物をパッケージ化する。README を書く。サンプルを追加する。きれいにする。

3. Lemon Squeezy ストアをセットアップする（30分）: アカウントを作成し、プロダクトを追加し、価格を設定する。組み込みのファイル配信を使う。

4. セールスページを書く（2時間）: 5つのセクション。最初の下書きにはローカル LLM を使う。自分の声で書き直す。

5. ソフトローンチ（1時間）: プロダクトのオーディエンスに関連する3つの場所に投稿する。

レッスン 2: コンテンツ収益化

「あなたはすでに、何千人もの人々がお金を払って学びたいことを知っている。」

最初の1ドルまで: 2〜4週間 継続的な時間コミットメント: 週5〜10時間 利益率: 70〜95%（プラットフォームによる）

コンテンツの経済学

コンテンツ収益化は他のすべてのエンジンとは異なる動きをする。スタートは遅いが、その後複利で増える。最初の月は $0 かもしれない。6ヶ月目は $500 かもしれない。12ヶ月目は $3,000 かもしれない。そして成長し続ける — コンテンツの半減期は日数ではなく年数で測られるからだ。

基本方程式:

コンテンツ収益 = トラフィック x コンバージョン率 x コンバージョンあたりの収益

例（テックブログ）:
  月間50,000ビジター x 2%のアフィリエイトクリック率 x 平均$5のコミッション
  = $5,000/月

例（ニュースレター）:
  5,000購読者 x 10%がプレミアムに転換 x $5/月
  = $2,500/月

例（YouTube）:
  10,000登録者、月間約50Kビュー
  = $500-1,000/月の広告収益
  + $500-1,500/月のスポンサーシップ（10K登録者に到達後）
  = $1,000-2,500/月

チャネル 1: アフィリエイト収益付きテクニカルブログ

仕組み: 本当に役立つ技術記事を書く。実際に使っている、推薦するツールやサービスへのアフィリエイトリンクを含める。読者がクリックして購入すると、コミッションを得る。

開発者コンテンツで報酬の良いアフィリエイトプログラム:

実際の収益例 — 月間50Kビジターの開発者ブログ:

月間トラフィック: 50,000ユニークビジター（12〜18ヶ月で達成可能）

収益内訳:
  ホスティングアフィリエイト (DigitalOcean, Hetzner):  $400-800/月
  ツールアフィリエイト (JetBrains, Tailwind UI):       $200-400/月
  サービスアフィリエイト (Vercel, Stripe):              $300-600/月
  ディスプレイ広告 (Carbon Ads for developers):         $200-400/月
  スポンサー記事 (月1-2本 @ $500-1,000):               $500-1,000/月

合計: $1,600-3,200/月

開発者のための SEO 基礎（実際に効果があるもの）:

マーケティング業界の人々から聞いた SEO のすべてを忘れよう。開発者コンテンツに重要なのは:

1. 具体的な質問に答える。 「Tauri 2.0 で SQLite をセットアップする方法」は「Tauri 入門」を毎回上回る。具体的なクエリは競合が少なく、インテントが高い。

2. ロングテールキーワードをターゲットにする。 Ahrefs（無料トライアル）、Ubersuggest（フリーミアム）、またはただの Google オートコンプリートを使おう。トピックを入力して Google が何を提案するか見る。

3. 動作するコードを含める。 Google は開発者クエリに対してコードブロックを含むコンテンツを優先する。完全に動作するサンプルは、理論的な説明を上回る。

4. 毎年更新する。 実際に最新の「2026年に X をデプロイする方法」の記事は、バックリンクが10倍ある2023年の記事を上回る。タイトルに年を入れて、最新状態を保つ。

5. 内部リンク。 記事同士をリンクする。Tauri セットアップ記事の下部に「関連: Tauri アプリに認証を追加する方法」。Google はこれらのリンクを辿る。

LLM を使ったコンテンツ作成の加速:

4ステッププロセス: (1) ローカル LLM でアウトラインを生成、(2) 各セクションをローカルでドラフト（無料）、(3) あなたの専門知識を追加 — LLM が提供できない注意点、意見、「本番環境で実際に使っているもの」、(4) 顧客向け品質のために API モデルで仕上げ。

LLM が作業の70%を処理する。あなたの専門知識が、人々がそれを読み、信頼し、アフィリエイトリンクをクリックする30%だ。

よくある間違い: LLM 生成コンテンツを大幅な編集なしに公開すること。読者にはわかる。Google にもわかる。そしてアフィリエイトリンクのコンバージョンに必要な信頼を構築しない。LLM なしでは自分の名前を出さないようなものなら、LLM ありでも名前を出すべきではない。

期待値を校正するための現実のニュースレターベンチマーク:

• TLDR Newsletter (Dan Ni): 120万以上の購読者、年間 $5-6.4M を生み出している。スポンサー1枠あたり最大 $18K を課金。オリジナルの報道ではなく、キュレーションで構築。(出典: growthinreverse.com/tldr)
• Pragmatic Engineer (Gergely Orosz): 40万以上の購読者、サブスクリプション ($15/月) だけで年間 $1.5M 以上。スポンサーゼロ — 純粋な購読者収益。(出典: growthinreverse.com/gergely)
• Cyber Corsairs AI (Beehiiv ケーススタディ): 1年未満で5万購読者と月間 $16K に成長。フォーカスしたニッチでは新規参入者もまだ突破できることを実証。(出典: blog.beehiiv.com)

これらは典型的な結果ではない — トップパフォーマーだ。しかし、モデルがスケールで機能し、収益の天井が実在することを証明している。

チャネル 2: プレミアム階層付きニュースレター

プラットフォーム比較:

開発者におすすめ: Beehiiv（成長機能、収益の手数料なし）または Ghost（フルコントロール、最良の SEO）。

LLM を活用したニュースレターパイプライン:

#!/usr/bin/env python3
"""newsletter_pipeline.py — Semi-automated newsletter production."""
import requests, json
from datetime import datetime

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
NICHE = "Rust ecosystem and systems programming"  # ← ここを変更

def fetch_hn_stories(limit=30) -> list[dict]:
    """Fetch top HN stories. Replace/extend with RSS feeds, Reddit API, etc."""
    story_ids = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json").json()[:limit]
    return [requests.get(f"https://hacker-news.firebaseio.com/v0/item/{sid}.json").json()
            for sid in story_ids]

def classify_and_summarize(items: list[dict]) -> list[dict]:
    """Use local LLM to score relevance and generate summaries."""
    results = []
    for item in items:
        prompt = f"""Rate relevance to {NICHE} (1-10). If >= 7, summarize in 2 sentences.
Title: "{item.get('title','')}" URL: {item.get('url','')}
Output JSON: {{"relevance": N, "summary": "...", "category": "Tool|Tutorial|News|Research|Opinion"}}"""

        resp = requests.post(OLLAMA_URL, json={"model": "llama3.1:8b", "prompt": prompt,
            "stream": False, "format": "json", "options": {"temperature": 0.3}})
        try:
            data = json.loads(resp.json()["response"])
            if data.get("relevance", 0) >= 7:
                item.update(data)
                results.append(item)
        except (json.JSONDecodeError, KeyError):
            continue
    return sorted(results, key=lambda x: x.get("relevance", 0), reverse=True)

def generate_draft(items: list[dict]) -> str:
    """Generate newsletter skeleton — you edit and add your expertise."""
    items_text = "\n".join(f"- [{i.get('title','')}]({i.get('url','')}) — {i.get('summary','')}"
                          for i in items[:8])
    prompt = f"""Write a {NICHE} newsletter. Items:\n{items_text}\n
Include: intro (2-3 sentences), each item with analysis (WHY it matters, WHAT to do),
Quick Takes section, closing. Be opinionated. Markdown format."""

    resp = requests.post(OLLAMA_URL, json={"model": "llama3.1:8b", "prompt": prompt,
        "stream": False, "options": {"temperature": 0.5, "num_ctx": 4096}})
    return resp.json()["response"]

if __name__ == "__main__":
    stories = fetch_hn_stories()
    relevant = classify_and_summarize(stories)
    draft = generate_draft(relevant)
    filename = f"newsletter-draft-{datetime.now().strftime('%Y-%m-%d')}.md"
    open(filename, "w").write(draft)
    print(f"Draft: {filename} — NOW add your expertise, fix errors, publish.")

時間投資: パイプラインのセットアップ後は週3〜4時間。LLM がキュレーションとドラフトを処理する。あなたは編集、洞察、そして購読者がお金を払う個人的な声を担当する。

チャネル 3: YouTube

YouTube は収益化が最も遅いが、天井が最も高い。YouTube の開発者コンテンツは慢性的に供給不足だ — 需要が供給をはるかに上回っている。

収益タイムライン（現実的）:

1-3ヶ月目:    $0（ライブラリ構築中、まだ収益化なし）
4-6ヶ月目:    $50-200/月（1,000登録者 + 4,000視聴時間で広告収益が始まる）
7-12ヶ月目:   $500-1,500/月（広告収益 + 最初のスポンサーシップ）
2年目:        $2,000-5,000/月（確立されたチャンネル、定期スポンサー付き）

2026年の開発者 YouTube で効くもの:

1. 「Xを Yで構築」チュートリアル（15〜30分） — 「Rust で CLI ツールを構築」「ローカル AI API を構築」
2. ツール比較 — 「2026年の Tauri vs Electron — どちらを使うべきか？」
3. 「30日間 X を試してみた」 — 「すべてのクラウドサービスをセルフホスト代替品に置き換えた」
4. アーキテクチャの深堀り — 「1日100万イベントを処理するシステムの設計方法」
5. 「学んだこと」振り返り — 「デジタルプロダクト販売6ヶ月 — 実際の数字」

必要な機材:

最小限（ここから始めよう）:
  スクリーンレコーディング: OBS Studio ($0)
  マイク: 任意のUSBマイク ($30-60) — またはヘッドセットマイク
  編集: DaVinci Resolve ($0) または CapCut ($0)
  合計: $0-60

快適（収益が正当化する時にアップグレード）:
  マイク: Blue Yeti または Audio-Technica AT2020 ($100-130)
  カメラ: Logitech C920 ($70) — フェイスカム希望の場合
  合計: $170-200

本音: 開発者コンテンツでは、オーディオ品質がビデオ品質の10倍重要だ。ほとんどの視聴者は見ているのではなく聴いている。$30のUSBマイク + OBSで始められる。最初の10本の動画が、まあまあの音質で良いコンテンツなら、登録者は増える。$2,000のカメラセットアップで悪いコンテンツなら、増えない。

あなたの番

1. コンテンツチャネルを選ぶ（15分）: ブログ、ニュースレター、または YouTube。1つを選ぶ。3つ同時にやろうとしないこと。スキルが異なり、時間のコミットメントが急速に複合する。

2. ニッチを定義する（30分）: 「プログラミング」ではない。「ウェブ開発」ではない。具体的なもの。「バックエンド開発者のための Rust」「ローカルファーストデスクトップアプリの構築」「中小企業向け AI 自動化」。具体的であるほど、成長が速い。

3. 最初のコンテンツを作成する（4〜8時間）: ブログ記事1本、ニュースレター1号、または YouTube 動画1本。出す。完璧を待たない。

4. 収益化インフラをセットアップする（1時間）: 関連するアフィリエイトプログラムに2〜3つ登録する。ニュースレタープラットフォームをセットアップする。あるいはまず公開して、後から収益化を追加する — コンテンツが先、収益は二の次。

5. スケジュールにコミットする（5分）: あらゆるコンテンツチャネルで週1回が最低限。書き留める: 「毎週[曜日]の[時間]に公開する。」オーディエンスは品質ではなく、一貫性で成長する。

レッスン 3: マイクロ SaaS

「特定のグループの人々の1つの問題を解決する小さなツール。彼らは喜んで月$9-29を払う。」

最初の1ドルまで: 4〜8週間 継続的な時間コミットメント: 週5〜15時間 利益率: 80〜90%（ホスティング + API コスト）

マイクロ SaaS の違い

マイクロ SaaS はスタートアップではない。ベンチャーキャピタルを探していない。次の Slack になろうとしていない。マイクロ SaaS は小さくてフォーカスされたツールで:

• 正確に1つの問題を解決する
• 月 $9-29 を課金する
• 1人で構築・維持できる
• 月 $20-100 で運用できる
• 月 $500-5,000 の収益を生む

美しさは制約にある。1つの問題。1人。1つの価格帯。

現実のマイクロ SaaS ベンチマーク:

• Pieter Levels (Nomad List, PhotoAI など): 従業員ゼロで年間約 $3M。PhotoAI 単独で月 $132K に達した。ソロ創業者マイクロ SaaS モデルのスケールを証明。(出典: fast-saas.com)
• Bannerbear (Jon Yongfook): 画像生成 API。1人でブートストラップして MRR $50K 以上に到達。(出典: indiepattern.com)
• 現実チェック: マイクロ SaaS プロダクトの70%は月 $1K 未満の収益。上記の生存者は外れ値だ。構築前に検証し、有料顧客がつくまでコストをほぼゼロに保つこと。(出典: softwareseni.com)

マイクロ SaaS アイデアの見つけ方

最良のマイクロ SaaS アイデアは、個人的に経験した問題から生まれる。しかし、見つけるためのフレームワークが必要なら、これだ:

「スプレッドシート置き換え」メソッド:

スプレッドシート、手動プロセス、または寄せ集めの無料ツールを使って、1つのシンプルなアプリであるべき何かをしているワークフローを探せ。それがあなたのマイクロ SaaS だ。

例:

• フリーランサーがクライアントプロジェクトを Google Sheets で追跡 → フリーランサー向けプロジェクトトラッカー ($12/月)
• 開発者が自分のサイドプロジェクトがまだ稼働しているか手動でチェック → インディーハッカー向けステータスページ ($9/月)
• コンテンツクリエイターが複数のプラットフォームに手動でクロスポスト → クロスポスト自動化 ($15/月)
• 小チームが Slack メッセージで API キーを共有 → チームシークレットマネージャー ($19/月)

「ひどい無料ツール」メソッド:

無料だからしぶしぶ使っているが、ひどいから嫌っている無料ツールを見つけよ。$9-29/月でより良いバージョンを作れ。

「フォーラムマイニング」メソッド:

Reddit、HN、ニッチな Discord サーバーで以下を検索:

• 「〜のツールはありますか...」
• 「〜があればいいのに...」
• 「〜を探しているんですが...」
• 「良い〜を知っている人はいますか...」

50人以上が質問していて、答えが「実はない」や「スプレッドシートを使っている」なら、それがマイクロ SaaS だ。

収益ポテンシャル付きの実際のマイクロ SaaS アイデア

マイクロ SaaS の構築: 完全ウォークスルー

実際に1つ構築しよう。シンプルなアップタイム監視サービスを構築する — 分かりやすく、便利で、フルスタックを実演できるからだ。

テックスタック（ソロ開発者向けに最適化）:

バックエンド:    Hono（軽量、高速、TypeScript）
データベース:   Turso（SQLite ベース、寛大な無料プラン）
認証:           Lucia（シンプル、セルフホスト認証）
決済:           Stripe（サブスクリプション）
ホスティング:   Vercel（関数の無料プラン）
ランディング:   同じ Vercel プロジェクトの静的 HTML
モニタリング:   自分のプロダクト（自分で使おう）

ローンチ時の月額コスト:

Vercel:       $0（無料プラン — 月100K関数呼び出し）
Turso:        $0（無料プラン — 9GBストレージ、月500M行読み取り）
Stripe:       取引ごとに 2.9% + $0.30（支払いを受けた時のみ）
ドメイン:     $1/月（$12/年）
合計:         スケールが必要になるまで $1/月

コア API セットアップ:

// src/index.ts — Hono API for uptime monitor
import { Hono } from "hono";
import { cors } from "hono/cors";
import { jwt } from "hono/jwt";
import Stripe from "stripe";

const app = new Hono();
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const PLAN_LIMITS = { free: 3, starter: 10, pro: 50 };

app.use("/api/*", cors());
app.use("/api/*", jwt({ secret: process.env.JWT_SECRET! }));

// Create a monitor (with plan-based limits)
app.post("/api/monitors", async (c) => {
  const userId = c.get("jwtPayload").sub;
  const { url, interval } = await c.req.json();
  const plan = await db.getUserPlan(userId);
  const count = await db.getMonitorCount(userId);

  if (count >= (PLAN_LIMITS[plan] || 3)) {
    return c.json({ error: "Monitor limit reached", upgrade_url: "/pricing" }, 403);
  }

  const monitor = await db.createMonitor({
    userId, url,
    interval: Math.max(interval, plan === "free" ? 300 : 60),
    status: "unknown",
  });
  return c.json(monitor, 201);
});

// Get all monitors for user
app.get("/api/monitors", async (c) => {
  const userId = c.get("jwtPayload").sub;
  return c.json(await db.getMonitors(userId));
});

// Stripe webhook for subscription management
app.post("/webhooks/stripe", async (c) => {
  const sig = c.req.header("stripe-signature")!;
  const event = stripe.webhooks.constructEvent(
    await c.req.text(), sig, process.env.STRIPE_WEBHOOK_SECRET!
  );

  if (event.type.startsWith("customer.subscription.")) {
    const sub = event.data.object as Stripe.Subscription;
    const plan = event.type.includes("deleted")
      ? "free"
      : sub.items.data[0]?.price?.lookup_key || "free";
    await db.updateUserPlan(sub.metadata.userId!, plan);
  }
  return c.json({ received: true });
});

// The monitoring worker — runs on a cron schedule (Vercel cron, Railway cron, etc.)
export async function checkMonitors() {
  const monitors = await db.getActiveMonitors();

  const results = await Promise.allSettled(
    monitors.map(async (monitor) => {
      const start = Date.now();
      try {
        const response = await fetch(monitor.url, {
          method: "HEAD",
          signal: AbortSignal.timeout(10000),
        });
        return { monitorId: monitor.id, status: response.status,
                 responseTime: Date.now() - start };
      } catch {
        return { monitorId: monitor.id, status: 0, responseTime: Date.now() - start };
      }
    })
  );

  // Store results and alert on status changes (up → down or down → up)
  for (const result of results) {
    if (result.status === "fulfilled") {
      await db.insertCheckResult(result.value);
      const monitor = monitors.find((m) => m.id === result.value.monitorId);
      if (monitor) {
        const isDown = result.value.status === 0 || result.value.status >= 400;
        if (isDown && monitor.status !== "down") await sendAlert(monitor, "down");
        if (!isDown && monitor.status === "down") await sendAlert(monitor, "recovered");
        await db.updateMonitorStatus(monitor.id, isDown ? "down" : "up");
      }
    }
  }
}

export default app;

Stripe サブスクリプションセットアップ（1回実行）:

// stripe-setup.ts — Create your product and pricing tiers
import Stripe from "stripe";
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

async function createPricing() {
  const product = await stripe.products.create({
    name: "UptimeBot", description: "Simple uptime monitoring for developers",
  });

  const starter = await stripe.prices.create({
    product: product.id, unit_amount: 900, currency: "usd",
    recurring: { interval: "month" }, lookup_key: "starter",
  });
  const pro = await stripe.prices.create({
    product: product.id, unit_amount: 1900, currency: "usd",
    recurring: { interval: "month" }, lookup_key: "pro",
  });

  console.log(`Starter: ${starter.id} ($9/mo) | Pro: ${pro.id} ($19/mo)`);

  // Use in your checkout:
  // const session = await stripe.checkout.sessions.create({
  //   mode: 'subscription',
  //   line_items: [{ price: starter.id, quantity: 1 }],
  //   success_url: 'https://yourapp.com/dashboard?upgraded=true',
  //   cancel_url: 'https://yourapp.com/pricing',
  // });
}
createPricing().catch(console.error);

ユニットエコノミクス

マイクロ SaaS を構築する前に、数字を確認しよう:

顧客獲得コスト (CAC):
  オーガニックマーケティング（ブログ、Twitter、HN）の場合: 約$0
  広告を出す場合: トライアル登録あたり$10-50、有料顧客あたり$30-150

  ターゲット: CAC < サブスクリプション収益の3ヶ月分
  例: CAC $30、価格 $12/月 → 2.5ヶ月で回収 ✓

顧客生涯価値 (LTV):
  LTV = 月額価格 x 平均顧客期間（月数）

  マイクロ SaaS の場合、平均チャーン率は月5-8%
  平均期間 = 1 / チャーン率
  5%チャーン時: 1/0.05 = 20ヶ月 → $12/月での LTV = $240
  8%チャーン時: 1/0.08 = 12.5ヶ月 → $12/月での LTV = $150

  ターゲット: LTV/CAC 比率 > 3

月間バーン:
  ホスティング (Vercel/Railway): $0-20
  データベース (Turso/PlanetScale): $0-20
  メール送信 (Resend): $0
  モニタリング（自分のプロダクト）: $0
  ドメイン: $1

  合計: $1-41/月

  損益分岐点: 1-5顧客（$9/月の場合）

よくある間違い: 損益分岐点に500顧客が必要なマイクロ SaaS を構築すること。インフラコストが月 $200 で $9/月を課金するなら、コストをカバーするだけで23顧客が必要だ。すべてを無料プランで始めよう。最初の顧客の支払いは純粋な利益であるべきで、インフラのカバーではない。

あなたの番

1. アイデアを見つける（2時間）: 「スプレッドシート置き換え」か「フォーラムマイニング」メソッドを使う。3つの潜在的なマイクロ SaaS アイデアを特定する。それぞれについて書き出す: 問題、ターゲットユーザー、価格、月 $1,000 の収益に必要な顧客数。

2. 構築前に検証する（1〜2日）: トップアイデアについて、5〜10人の潜在顧客を見つけて聞く: 「[X] を構築しています。月 $[Y] を払いますか？」 ソリューションを説明するのではなく — 問題を説明して、彼らの目が輝くか見る。

3. MVP を構築する（2〜4週間）: コア機能のみ。認証、ツールが行う1つのこと、Stripe 課金。それだけ。管理ダッシュボードなし。チーム機能なし。API なし。1ユーザー、1機能、1つの価格。

4. デプロイしてローンチする（1日）: Vercel か Railway にデプロイする。ドメインを購入する。ランディングページをセットアップする。3〜5つの関連コミュニティに投稿する。

5. ユニットエコノミクスを追跡する（継続的）: 初日から CAC、チャーン、MRR を追跡する。10顧客で数字が合わないなら、100顧客でも合わない。

レッスン 4: オートメーション・アズ・ア・サービス

「企業は、ツール同士をつなぐために何千ドルも払ってくれる。」

最初の1ドルまで: 1〜2週間 継続的な時間コミットメント: 様々（プロジェクトベース） 利益率: 80〜95%（主なコストはあなたの時間）

なぜオートメーションは高収入なのか

ほとんどの企業には、従業員の週10〜40時間を消費する手動ワークフローがある。受付がウェブフォームの送信を手動で CRM に入力している。経理がメールの請求書データをコピペで QuickBooks に入力している。マーケティングマネージャーが5つのプラットフォームに手動でコンテンツをクロスポストしている。

これらの企業はオートメーションの存在を知っている。Zapier のことは聞いたことがある。しかし自分ではセットアップできない — そして Zapier のプリビルト統合は、彼らの特定のワークフローを完璧に処理することはほとんどない。

そこであなたの出番だ。週10〜40時間を節約するカスタムオートメーションを構築して $500-$5,000 を課金する。その従業員の時間を時給 $20 としても、月 $800-$3,200 の節約になる。あなたの一回の $2,500 の料金は1ヶ月で元が取れる。

これはコース全体で最も簡単なセールスの1つだ。

プライバシーのセールスポイント

ここでモジュール S のローカル LLM スタックが武器になる。（まだローカル LLM をセットアップしていなければ、モジュール S のレッスン 3 に戻ろう。これがプレミアム価格のオートメーション作業の基盤だ。）

ほとんどのオートメーションエージェンシーはクラウドベースの AI を使う。クライアントのデータは Zapier を通り、OpenAI を通り、戻ってくる。多くの企業 — 特に法律事務所、医療機関、ファイナンシャルアドバイザー、EU に拠点を置く企業 — にとって、これは論外だ。

あなたのピッチ: 「データを非公開で処理するオートメーションを構築します。顧客記録、請求書、コミュニケーションはインフラから一切出ません。サードパーティの AI プロセッサなし。GDPR および現地のデータ保護規制に完全準拠。」

このピッチは、クラウドオートメーションエージェンシーには手が届かない案件を獲得する。そしてプレミアム料金を課金できる。

実際のプロジェクト例と価格設定

プロジェクト 1: 不動産会社向けリード選別 — $3,000

問題: エージェンシーはウェブサイト、メール、SNS から週200件以上の問い合わせを受ける。
     エージェントは不適格なリード（冷やかし、エリア外、事前承認なし）への
     対応に時間を浪費している。

ソリューション:
  1. Webhook がすべての問い合わせソースを単一のキューにキャプチャ
  2. ローカル LLM が各リードを分類: ホット / ウォーム / コールド / スパム
  3. ホットリード: 担当エージェントに SMS で即時通知
  4. ウォームリード: 関連物件で自動返信し、フォローアップをスケジュール
  5. コールドリード: ナーチャリングメールシーケンスに追加
  6. スパム: 黙ってアーカイブ

ツール: n8n（セルフホスト）、Ollama、Twilio（SMS用）、既存の CRM API

構築時間: 15-20時間
あなたのコスト: 約$0（セルフホストツール + 彼らのインフラ）
彼らの節約: エージェント時間の週約20時間 = 月$2,000以上

プロジェクト 2: 法律事務所向け請求書処理 — $2,500

問題: 事務所は月50-100件のベンダー請求書をPDF添付で受け取る。
     リーガルアシスタントが各件を手動で課金システムに入力。
     月10時間以上かかる。エラーが起きやすい。

ソリューション:
  1. メールルールが請求書を処理用受信箱に転送
  2. PDF 抽出がテキストを取り出す（pdf-extract または OCR）
  3. ローカル LLM が抽出: ベンダー、金額、日付、カテゴリ、課金コード
  4. 構造化データが課金システム API にポストされる
  5. 例外（低信頼度の抽出）はレビューキューに入る
  6. マネージングパートナーへの週次サマリーメール

ツール: カスタム Python スクリプト、Ollama、メール API、課金システム API

構築時間: 12-15時間
あなたのコスト: 約$0
彼らの節約: リーガルアシスタント時間の月約10時間 + エラー減少

プロジェクト 3: マーケティングエージェンシー向けコンテンツリパーパスパイプライン — $1,500

問題: エージェンシーは各クライアントに週1本の長文ブログ記事を作成。
     その後、各記事からSNSスニペット、メールサマリー、
     LinkedIn投稿を手動で作成。1記事あたり5時間かかる。

ソリューション:
  1. 新しいブログ記事がパイプラインをトリガー（RSSまたはWebhook）
  2. ローカル LLM が生成:
     - 5つの Twitter/X 投稿（異なる角度、異なるフック）
     - 1つの LinkedIn 投稿（長め、プロフェッショナルなトーン）
     - 1つのメールニュースレターサマリー
     - 3つの Instagram キャプション案
  3. すべての生成コンテンツがレビューダッシュボードに入る
  4. 人間がレビュー、編集し、Buffer/Hootsuite でスケジュール

ツール: n8n、Ollama、Buffer API

構築時間: 8-10時間
あなたのコスト: 約$0
彼らの節約: 1記事あたり約4時間 x 週4記事 = 週16時間

オートメーションの構築: n8n の例

n8n はセルフホスト可能なオープンソースのワークフロー自動化ツールだ（docker run -d --name n8n -p 5678:5678 n8nio/n8n）。クライアントのデータがあなた/彼らのインフラに留まるため、プロフェッショナルな選択だ。

よりシンプルなデプロイメントには、同じ請求書処理を純粋な Python スクリプトで（Python はオートメーション作業のスタンダードだ。あなたのメインスタックでなくても）:

#!/usr/bin/env python3
"""
invoice_processor.py — Automated invoice data extraction.
Processes PDF invoices using local LLM, outputs structured data.
"""
import json, subprocess, requests
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "llama3.1:8b"
WATCH_DIR, PROCESSED_DIR, REVIEW_DIR = (
    Path("./invoices/incoming"), Path("./invoices/processed"), Path("./invoices/review")
)

@dataclass
class InvoiceData:
    filename: str; vendor: str; invoice_number: str; date: str
    amount: float; currency: str; category: str; confidence: float
    needs_review: bool; line_items: list

def extract_text_from_pdf(pdf_path: Path) -> str:
    try:
        return subprocess.run(
            ["pdftotext", "-layout", str(pdf_path), "-"],
            capture_output=True, text=True, timeout=30
        ).stdout
    except FileNotFoundError:
        import PyPDF2
        return "\n".join(p.extract_text() for p in PyPDF2.PdfReader(str(pdf_path)).pages)

def extract_invoice_data(text: str, filename: str) -> InvoiceData:
    prompt = f"""Extract invoice data from this text. Output ONLY valid JSON.

Invoice text:
---
{text[:3000]}
---

Extract: {{"vendor": "...", "invoice_number": "...", "date": "YYYY-MM-DD",
"amount": 0.00, "currency": "USD",
"category": "Legal Services|Office Supplies|Software|Professional Services|Other",
"line_items": [{{"description": "...", "amount": 0.00}}],
"confidence": 0.0 to 1.0}}"""

    response = requests.post(OLLAMA_URL, json={
        "model": MODEL, "prompt": prompt, "stream": False,
        "format": "json", "options": {"temperature": 0.1}
    })
    try:
        d = json.loads(response.json()["response"])
        conf = float(d.get("confidence", 0))
        return InvoiceData(filename=filename, vendor=d.get("vendor", "UNKNOWN"),
            invoice_number=d.get("invoice_number", ""), date=d.get("date", ""),
            amount=float(d.get("amount", 0)), currency=d.get("currency", "USD"),
            category=d.get("category", "Other"), confidence=conf,
            needs_review=conf < 0.7, line_items=d.get("line_items", []))
    except (json.JSONDecodeError, KeyError, ValueError):
        return InvoiceData(filename=filename, vendor="EXTRACTION_FAILED",
            invoice_number="", date="", amount=0.0, currency="USD",
            category="Other", confidence=0.0, needs_review=True, line_items=[])

def process_invoices():
    for d in [WATCH_DIR, PROCESSED_DIR, REVIEW_DIR]: d.mkdir(parents=True, exist_ok=True)
    pdfs = list(WATCH_DIR.glob("*.pdf"))
    if not pdfs: return print("No invoices to process.")

    for pdf_path in pdfs:
        text = extract_text_from_pdf(pdf_path)
        if not text.strip():
            pdf_path.rename(REVIEW_DIR / pdf_path.name); continue

        invoice = extract_invoice_data(text, pdf_path.name)
        dest = REVIEW_DIR if invoice.needs_review else PROCESSED_DIR
        pdf_path.rename(dest / pdf_path.name)

        with open("./invoices/extracted.jsonl", "a") as f:
            f.write(json.dumps(asdict(invoice)) + "\n")
        print(f"  {'Review' if invoice.needs_review else 'OK'}: "
              f"{invoice.vendor} ${invoice.amount:.2f} ({invoice.confidence:.0%})")

if __name__ == "__main__":
    process_invoices()

オートメーションクライアントの見つけ方

LinkedIn（オートメーションクライアントを見つけるのに最も ROI が高い）:

1. ヘッドラインを変更: 「面倒なビジネスプロセスを自動化します | プライバシーファーストの AI オートメーション」
2. 週2〜3回、オートメーションの成果について投稿: 「[クライアントタイプ]の[プロセス]を自動化して週15時間を節約。データはインフラから出ません。」
3. ターゲット業界の LinkedIn グループに参加（不動産エージェント、法律事務所マネージャー、マーケティングエージェンシーオーナー）
4. エリアの中小企業オーナーに1日5〜10件のパーソナライズドコネクション依頼を送る

ローカルビジネスネットワーク:

• 商工会議所イベント（1つ出席して「ビジネスプロセスを自動化しています」と言及する）
• BNI（Business Network International）グループ
• コワーキングスペースコミュニティ

Upwork（最初の2〜3プロジェクト向け）:

検索キーワード: 「automation」「data processing」「workflow automation」「Zapier expert」「API integration」。1日5件のプロジェクトに、具体的で関連性のある提案で応募する。最初の2〜3プロジェクトは低い料金（$500-1,000）でレビューを構築する。その後は市場価格で課金する。

オートメーション契約テンプレート

常に契約書を使うこと。契約書には最低限この7セクションが必要:

1. 作業範囲 — 具体的な説明 + 成果物リスト + ドキュメント
2. タイムライン — 推定完了日数、開始日 = デポジット受領時
3. 価格 — 総額、50%前払い（返金不可）、50%は納品時
4. データ取り扱い — 「すべてのデータをローカルで処理。サードパーティサービスなし。開発者は完了後30日以内にすべてのクライアントデータを削除。」
5. 修正 — 2回込み、追加は $150/時間
6. メンテナンス — バグ修正とモニタリングのオプションリテイナー
7. 知的財産 — クライアントがオートメーションを所有。開発者は汎用パターンの再利用権を保持。

Avodocs.com または Bonsai の無料テンプレートを出発点として使い、データ取り扱い条項（セクション4）を追加する — ほとんどのテンプレートが欠いているもので、それがあなたの競争優位性だ。

本音: 50%の前払いデポジットは交渉の余地がない。スコープクリープと納品後に音信不通になるクライアントからあなたを守る。50%の前払いに応じないクライアントは、100%を後で払わないクライアントだ。

あなたの番

1. 3つの潜在的オートメーションプロジェクトを特定する（1時間）: やり取りしている企業を考えよう（歯科医、大家の管理会社、行きつけのカフェ、美容院）。彼らが行っている手動プロセスで、あなたが自動化できるものは何か？

2. 1つの価格を設定する（30分）: 計算する: 構築に何時間かかるか、クライアントへの価値はいくらか（節約時間 x それらの時間の時給コスト）、そして適正価格はいくらか？価格はあなたが生み出す節約の1〜3ヶ月分にするべきだ。

3. デモを構築する（4〜8時間）: 上記の請求書処理をターゲット業界向けにカスタマイズする。動作している2分間のスクリーン録画を録る。このデモがあなたのセールスツールだ。

4. 5人の潜在クライアントにアプローチする（2時間）: LinkedIn、メール、またはローカルビジネスに直接行く。デモを見せる。手動プロセスについて聞く。

5. 契約テンプレートをセットアップする（30分）: 上記のテンプレートを自分の情報でカスタマイズする。クライアントが「はい」と言った同じ日に送れるよう準備しておく。

レッスン 5: API プロダクト

「ローカル LLM を収益を生むエンドポイントに変えよう。」

最初の1ドルまで: 2〜4週間 継続的な時間コミットメント: 週5〜10時間（メンテナンス + マーケティング） 利益率: 70〜90%（コンピューティングコストによる）

API プロダクトモデル

API プロダクトは何らかの機能 — 通常はカスタム処理を施したローカル LLM — をクリーンな HTTP エンドポイントの背後にラップし、他の開発者が利用料を払って使う。あなたがインフラ、モデル、ドメイン専門知識を担当する。彼らはシンプルな API コールを得る。

これはバックエンドに慣れた開発者にとって、このコース内で最もスケーラブルなエンジンだ。一度構築すれば、新しい顧客ごとに最小限の追加コストで収益が追加される。

良い API プロダクトの条件

すべての API に支払う価値があるわけではない。開発者が API に支払うのは:

1. コスト以上の時間を節約する時。 $29/月のレジュメパーサー API がチームの月20時間の手動作業を節約する。簡単なセールスだ。
2. 自分で簡単にできないことをする時。 ファインチューニングされたモデル、プロプライエタリなデータセット、または複雑な処理パイプライン。
3. 社内構築より信頼性が高い時。 メンテナンスされ、ドキュメント化され、監視されている。LLM デプロイメントの世話をしたくない。

実際の API プロダクトのアイデアと価格設定:

API プロダクトの構築: 完全な例

ドキュメント分類 API を構築しよう — リーガルテックスタートアップが $99/月を払うようなものだ。

テックスタック:

ランタイム:        Hono (TypeScript) on Vercel Edge Functions
LLM:              Ollama（ローカル、開発用）+ Anthropic API（本番フォールバック）
認証:             API キーベース（シンプル、開発者フレンドリー）
レート制限:       Upstash Redis（無料プラン: 1日10Kリクエスト）
課金:             Stripe 使用量ベース課金
ドキュメント:     OpenAPI スペック + ホストされたドキュメント

完全な API 実装:

// src/api.ts — Document Classification API
import { Hono } from "hono";
import { cors } from "hono/cors";
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const app = new Hono();
const ratelimit = new Ratelimit({
  redis: new Redis({ url: process.env.UPSTASH_REDIS_URL!, token: process.env.UPSTASH_REDIS_TOKEN! }),
  limiter: Ratelimit.slidingWindow(100, "1 h"),
});

// Auth middleware: API key → user lookup → rate limit → track usage
async function authMiddleware(c: any, next: any) {
  const apiKey = c.req.header("X-API-Key") || c.req.header("Authorization")?.replace("Bearer ", "");
  if (!apiKey) return c.json({ error: "Missing API key." }, 401);

  const user = await db.getUserByApiKey(apiKey);
  if (!user) return c.json({ error: "Invalid API key." }, 401);

  const { success, remaining, reset } = await ratelimit.limit(user.id);
  c.header("X-RateLimit-Remaining", remaining.toString());
  if (!success) return c.json({ error: "Rate limit exceeded.", reset_at: new Date(reset).toISOString() }, 429);

  await db.incrementUsage(user.id);
  c.set("user", user);
  return next();
}

app.use("/v1/*", cors());
app.use("/v1/*", authMiddleware);

// Main classification endpoint
app.post("/v1/classify", async (c) => {
  const start = Date.now();
  const { text, domain = "auto" } = await c.req.json();

  if (!text) return c.json({ error: "Missing 'text' field." }, 400);
  if (text.length > 50000) return c.json({ error: "Text exceeds 50K char limit." }, 400);

  const prompt = `Classify this document. Domain: ${domain === "auto" ? "detect automatically" : domain}.
Document: ${text.slice(0, 5000)}
Respond with JSON: {"domain", "category", "confidence": 0-1, "subcategories": [],
"key_entities": [{"type", "value", "confidence"}], "summary": "one sentence"}`;

  try {
    // Try local Ollama first, fallback to Anthropic API
    let result;
    try {
      const resp = await fetch("http://127.0.0.1:11434/api/generate", {
        method: "POST",
        body: JSON.stringify({ model: "llama3.1:8b", prompt, stream: false, format: "json",
          options: { temperature: 0.1 } }),
        signal: AbortSignal.timeout(30000),
      });
      result = JSON.parse((await resp.json()).response);
    } catch {
      const resp = await fetch("https://api.anthropic.com/v1/messages", {
        method: "POST",
        headers: { "Content-Type": "application/json", "x-api-key": process.env.ANTHROPIC_API_KEY!,
          "anthropic-version": "2023-06-01" },
        body: JSON.stringify({ model: "claude-3-5-haiku-20241022", max_tokens: 1024,
          messages: [{ role: "user", content: prompt }] }),
      });
      result = JSON.parse((await resp.json()).content[0].text);
    }

    result.document_id = crypto.randomUUID();
    result.processing_time_ms = Date.now() - start;
    await db.logApiCall(c.get("user").id, "classify", result.processing_time_ms);
    return c.json(result);
  } catch (error: any) {
    return c.json({ error: "Classification failed", message: error.message }, 500);
  }
});

app.get("/v1/usage", async (c) => {
  const user = c.get("user");
  const usage = await db.getMonthlyUsage(user.id);
  const plan = await db.getUserPlan(user.id);
  return c.json({ requests_used: usage.count, requests_limit: plan.requestLimit, plan: plan.name });
});

export default app;

API の価格ページコンテンツ:

無料プラン:        月100リクエスト、5K文字制限        $0
Starter:          月2,000リクエスト、50K文字制限      $29/月
Professional:     月10,000リクエスト、50K文字制限     $99/月
Enterprise:       カスタム制限、SLA、専任サポート      お問い合わせ

Stripe での使用量ベース課金

// billing.ts — Report usage to Stripe for metered billing

async function reportUsageToStripe(userId: string) {
  const user = await db.getUser(userId);
  if (!user.stripeSubscriptionItemId) return;

  const usage = await db.getUnreportedUsage(userId);

  if (usage.count > 0) {
    await stripe.subscriptionItems.createUsageRecord(
      user.stripeSubscriptionItemId,
      {
        quantity: usage.count,
        timestamp: Math.floor(Date.now() / 1000),
        action: "increment",
      }
    );

    await db.markUsageReported(userId, usage.ids);
  }
}

// Run this hourly via cron
// Vercel: vercel.json cron config
// Railway: railway cron
// Self-hosted: system cron

トラクションを得た時のスケーリング

API が実際のユーザーを得始めたら、スケーリングパスはこうだ。専用 GPU がなければ、スケーリングカーブの早い段階でクラウド推論（Replicate, Together.ai）に移行したいだろう:

ステージ 1: 0-100顧客
  - ローカル Ollama + Vercel edge functions
  - 月額コスト: $0-20
  - 収益: $0-5,000/月

ステージ 2: 100-500顧客
  - LLM 推論を専用 VPS に移行 (Hetzner GPU, $50-150/月)
  - 繰り返しクエリに Redis キャッシュを追加
  - 月額コスト: $50-200
  - 収益: $5,000-25,000/月

ステージ 3: 500+顧客
  - ロードバランサーの背後に複数の推論ノード
  - オーバーフロー用にマネージド推論 (Replicate, Together.ai) を検討
  - 月額コスト: $200-1,000
  - 収益: $25,000+/月

よくある間違い: 10顧客になる前にスケールのための過剰設計。最初のバージョンは無料プランで動かすべきだ。スケーリングの問題は良い問題だ。来た時に解決しよう。来る前ではなく。

あなたの番

1. API のニッチを特定する（1時間）: よく知っているドメインは何か？法律？金融？ヘルスケア？EC？最良の API プロダクトは、深いドメイン知識と AI 能力の組み合わせから生まれる。

2. 概念実証を構築する（8〜16時間）: 1つのエンドポイント、1つの機能、認証なし（ローカルでテストするだけ）。10個のサンプルドキュメントで分類/抽出/分析を正しく動作させる。

3. 認証と課金を追加する（4〜8時間）: API キー管理、Stripe 統合、使用量追跡。上記のコードでこの80%がカバーされる。

4. API ドキュメントを書く（2〜4時間）: Stoplight を使うか、OpenAPI スペックを手書きする。良いドキュメントは API プロダクト採用の第1の要因だ。

5. 開発者マーケットプレイスでローンチする（1時間）: Product Hunt、Hacker News、関連するサブレディットに投稿。開発者から開発者へのマーケティングは API プロダクトに最も効果的。

レッスン 6: コンサルティングとフラクショナル CTO

「始めるのが最速のエンジンで、他のすべてに資金を提供する最良の方法。」

最初の1ドルまで: 1週間（本当に） 継続的な時間コミットメント: 週5〜20時間（自分でダイヤルを制御） 利益率: 95%以上（唯一のコストはあなたの時間）

なぜコンサルティングがほとんどの開発者のエンジン #1 なのか

今四半期ではなく今月に収入が必要なら、答えはコンサルティングだ。構築するプロダクトもない。育てるオーディエンスもない。セットアップするマーケティングファネルもない。あなたと、あなたの専門知識と、それを必要としている誰かだけだ。

計算:

$200/時間 x 週5時間 = $4,000/月
$300/時間 x 週5時間 = $6,000/月
$400/時間 x 週5時間 = $8,000/月

これはフルタイムの仕事と並行してだ。

「$200/時間は課金できない。」いや、できる。これについてはすぐ後で。

実際に何を売っているか

「プログラミング」を売っているのではない。以下のいずれかを売っている:

1. 時間を節約する専門知識。 「あなたのチームが80時間かけて解決するところを、10時間で Kubernetes クラスタを正しくセットアップします。」
2. リスクを低減する知識。 「ローンチ前にアーキテクチャを監査して、初日に10,000ユーザーでスケーリング問題を発見することを防ぎます。」
3. 意思決定する判断力。 「3つのベンダーオプションを評価し、制約に合うものを推薦します。」
4. チームのブロックを解除するリーダーシップ。 「機能開発のスピードを落とさずに、[新技術] への移行をエンジニアリングチームを率いて行います。」

フレーミングが重要だ。「Python を書きます」は $50/時間の価値。「2週間でデータパイプラインの処理時間を60%削減します」は $300/時間の価値。

文脈のための実際のレートデータ:

• Rust コンサルティング: 平均 $78/時間、経験豊富なコンサルタントは標準的な作業で最大 $143/時間。アーキテクチャと移行コンサルティングはそれ以上。(出典: ziprecruiter.com)
• AI/ML コンサルティング: 実装作業に $120-250/時間。戦略的 AI コンサルティング（アーキテクチャ、デプロイメント計画）はエンタープライズ規模で $250-500/時間。(出典: debutinfotech.com)

2026年のホットなコンサルティングニッチ

今週中に最初のコンサルティングクライアントを獲得する方法

Day 1: LinkedIn ヘッドラインを更新する。悪い例: 「BigCorp のシニアソフトウェアエンジニア」 良い例: 「エンジニアリングチームの AI モデルの自社インフラへのデプロイを支援 | Rust + ローカル AI」

Day 2: LinkedIn に3つの投稿を書く。(1) 実数値を伴う技術的洞察を共有。(2) 達成した具体的な成果を共有。(3) 直接ヘルプを提供: 「今月、[あなたのニッチ] を検討中のチーム向けに2件のコンサルティング契約を受け付けます。無料30分アセスメントの DM をどうぞ。」

Day 3-5: CTO とエンジニアリングマネージャーに10件のパーソナライズドアウトリーチメッセージを送る。テンプレート: 「[会社] が [具体的な観察] していることに気づきました。私はチームの [バリュープロップ] を支援しています。最近 [類似企業] の [成果] 達成を支援しました。20分の通話は有益でしょうか？」

Day 5-7: コンサルティングプラットフォームに応募: Toptal（プレミアム、$100-200+/時間、2〜4週間のスクリーニング）、Arc.dev（リモート重視、より速いオンボーディング）、Lemon.io（ヨーロッパ重視）、Clarity.fm（分単位のコンサルテーション）。

レート交渉

レートの設定方法:

ステップ 1: ニッチの市場レートを調べる
  - Toptal の公開されている範囲をチェック
  - 開発者の Slack/Discord コミュニティで聞く
  - 類似コンサルタントの公開レートを見る

ステップ 2: 範囲の上限から始める
  - 市場が $150-300/時間なら、$250-300 を提示
  - 値下げ交渉されたら、市場レートに着地する
  - 交渉されなければ、市場以上を得ている

ステップ 3: レートを下げない — 代わりにスコープを追加する
  悪い:  「$300 の代わりに $200 でできます。」
  良い:  「$200/時間なら X と Y ができます。$300/時間なら、
         Z と継続サポートも行います。」

バリューアンカーテクニック:

レートを提示する前に、提供するものの価値を数値化する:

「お話の内容に基づくと、この移行は来四半期でチームの
約200エンジニアリング時間を節約します。チームの
負荷込みコストが $150/時間だとすると、$30,000 の節約です。
このプロジェクトのリード料は $8,000 です。」

（$30,000 の節約に対して $8,000 = クライアントにとって 3.75 倍の ROI）

最大レバレッジのためのコンサルティング構造化

コンサルティングの罠は、時間をお金に交換することだ。抜け出そう:

1. すべてをドキュメント化する — すべてのエンゲージメントが移行ガイド、アーキテクチャドキュメント、セットアップ手順を生む。クライアント固有の詳細を削除すれば、プロダクト（レッスン1）やブログ記事（レッスン2）になる。
2. 繰り返しの作業をテンプレート化する — 3クライアントで同じ問題？それはマイクロ SaaS（レッスン3）かデジタルプロダクト（レッスン1）だ。
3. トークをして、クライアントを得る — 1回の30分ミートアップトークが2〜3のクライアント会話を生む。役立つことを教える; 人々が集まってくる。
4. 書いてから、課金する — 特定の技術的課題についてのブログ記事が、まさにそれを抱えていて助けが必要な人を引き付ける。

秘密兵器としての 4DA の活用

ほとんどのコンサルタントが持っていない競争優位がある: 自分のニッチで何が起きているかを、クライアントよりも先に知っている。

4DA はシグナルを浮上させる — 新しい脆弱性、トレンドの技術、破壊的変更、規制の更新。クライアントに「ところで、[彼らが使っているライブラリ] に昨日公開された新しい脆弱性があります。対処のための推薦事項をお伝えします」と言及すると、超人的な認識力を持っているように見える。

その認識力がプレミアムレートを正当化する。クライアントは、事後的にググるのではなく、積極的に情報を持っているコンサルタントにより多く支払う。

本音: コンサルティングは他のエンジンに資金を提供する最良の方法だ。1〜3ヶ月目のコンサルティング収益を使って、マイクロ SaaS（レッスン3）やコンテンツ事業（レッスン2）に資金を投入しよう。目標は永遠にコンサルティングすることではない — 時間なしに収入を生むものを構築するための滑走路を得るために、今コンサルティングすることだ。

あなたの番

1. LinkedIn を更新する（30分）: 新しいヘッドライン、新しい「概要」セクション、専門知識についてのフィーチャード投稿。これがあなたのストアフロントだ。

2. LinkedIn の投稿を1つ書いて公開する（1時間）: 技術的洞察、成果、またはオファーを共有する。ピッチではない — まず価値。

3. 5件のダイレクトアウトリーチメッセージを送る（1時間）: パーソナライズされた、具体的な、価値志向のもの。上記のテンプレートを使う。

4. コンサルティングプラットフォームに1つ応募する（30分）: Toptal、Arc、または Lemon.io。プロセスを開始する — 時間がかかる。

5. レートを設定する（15分）: ニッチの市場レートを調査する。レートを書き留める。端数を切り捨てない。

レッスン 7: オープンソース + プレミアム

「公開で構築し、信頼を獲得し、ピラミッドのトップを収益化する。」

最初の1ドルまで: 4〜12週間 継続的な時間コミットメント: 週10〜20時間 利益率: 80〜95%（ホスティングバージョンのインフラコストによる）

オープンソースビジネスモデル

オープンソースは慈善事業ではない。配布戦略だ。

ロジックはこうだ:

1. ツールを構築してオープンソース化する
2. 開発者がそれを見つけ、使い、依存するようになる
3. それらの開発者の一部は企業で働いている
4. それらの企業は個人には不要な機能を必要とする: SSO、チーム管理、監査ログ、優先サポート、SLA、ホストされたバージョン
5. それらの企業がプレミアムバージョンにお金を払う

無料バージョンがあなたのマーケティング。プレミアムバージョンがあなたの収益。

ライセンスの選択

ライセンスがモートを決定する。慎重に選ぼう。

ソロ開発者におすすめ: FSL または AGPL。

• 企業がセルフホストするものを構築する場合: AGPL（AGPL の義務を回避するために商用ライセンスを購入してくれる）

• 2年間完全にコントロールしたいものを構築する場合: FSL（市場ポジションを確立する間、フォークによる競合を防ぐ）

よくある間違い: 「オープンソースは無料であるべき」だから MIT を選ぶこと。MIT は寛大で、それは称賛に値する。しかし VC に資金を受けた企業があなたの MIT プロジェクトをフォークし、決済レイヤーを追加し、あなたを上回るマーケティングをしたら、あなたは投資家に仕事を寄付したことになる。ビジネスを構築するのに十分な期間、自分の仕事を保護してから、開放しよう。

オープンソースプロジェクトのマーケティング

GitHub スターはバニティメトリクスだが、採用を促進するソーシャルプルーフでもある。獲得方法:

1. README がランディングページ

README に必要なもの:

• 一文の説明 — ツールが何をし、誰のためのものか
• スクリーンショットか GIF — ツールの動作を示す（これだけでクリック率が2倍になる）
• クイックスタート — npm install x か cargo install x と最初のコマンド
• 機能リスト — 無料とプレミアムの明確なラベル付き
• バッジウォール — ビルドステータス、バージョン、ライセンス、ダウンロード数
• 「なぜこのツール？」 — 何が違うかの3〜5文

2. Show HN 投稿（ローンチ日）

Hacker News の「Show HN」投稿は、開発者ツールにとって最も効果的なローンチチャネルだ。明確で事実に基づくタイトルを書く: 「Show HN: [ツール名] — [10語以内で何をするか]」 コメントで動機、技術的決定、フィードバックを求めていることを説明する。

3. Reddit ローンチ戦略

関連するサブレディットに投稿する（Rust ツールなら r/rust、セルフホストツールなら r/selfhosted、ウェブツールなら r/webdev）。解決した問題とその方法について本物の投稿を書く。GitHub にリンクする。営業的にならない。

4. 「Awesome」リストへの投稿

すべてのフレームワークと言語は GitHub に「awesome-X」リストがある。そこにリストされると持続的なトラフィックが生まれる。関連リストを見つけ、基準を満たしているか確認し、PR を送る。

収益モデル: オープンコア

ソロ開発者にとって最も一般的なオープンソース収益モデル:

無料（オープンソース）:
  - コア機能
  - CLI インターフェース
  - ローカルストレージ
  - コミュニティサポート（GitHub Issues）
  - セルフホストのみ

PRO ($12-29/月/ユーザー):
  - 無料のすべて
  - GUI / ダッシュボード
  - クラウド同期またはホストされたバージョン
  - 優先サポート（24時間以内の応答）
  - 高度な機能（分析、レポート、統合）
  - メールサポート

TEAM ($49-99/月/チーム):
  - Pro のすべて
  - SSO / SAML 認証
  - ロールベースアクセス制御
  - 監査ログ
  - 共有ワークスペース
  - チーム管理

ENTERPRISE（カスタム価格）:
  - Team のすべて
  - オンプレミスデプロイメント支援
  - SLA（99.9%稼働率保証）
  - 専用サポートチャネル
  - カスタム統合
  - 請求書払い（ネット30）

実際の収益例

校正のための現実のオープンソースビジネス:

• Plausible Analytics: プライバシーファーストのウェブ分析。AGPL ライセンス。完全にブートストラップ。12K の購読者で ARR $3.1M に到達。ベンチャーキャピタルなし。AGPL デュアルライセンスモデルがソロ/小チームプロダクトで機能することを証明。(出典: plausible.io/blog)
• Ghost: オープンソースのパブリッシングプラットフォーム。2024年の収益 $10.4M、24K の顧客。オープンコアプロジェクトとして始まり、コミュニティファースト戦略で成長。(出典: getlatka.com)

プレミアム階層を持つ小規模なオープンソースプロジェクトの典型的な成長はこうだ:

パターン: スロースタート、複利成長。18ヶ月で MRR $5,430 のツール = 年間 $65K。作業のほとんどは1〜6ヶ月目。その後はコミュニティが成長を駆動する。Plausible の軌跡は、18ヶ月以降も複利が続くとどうなるかを示している。

ライセンスと機能ゲーティングのセットアップ

// license.ts — Simple feature gating for open core
type Plan = "free" | "pro" | "team" | "enterprise";

const PLAN_CONFIG: Record<Plan, { maxProjects: number; features: Set<string> }> = {
  free:       { maxProjects: 3,        features: new Set(["core", "cli", "local_storage", "export"]) },
  pro:        { maxProjects: 20,       features: new Set(["core", "cli", "local_storage", "export",
                "dashboard", "cloud_sync", "analytics", "api_access", "integrations"]) },
  team:       { maxProjects: 100,      features: new Set(["core", "cli", "local_storage", "export",
                "dashboard", "cloud_sync", "analytics", "api_access", "integrations",
                "sso", "rbac", "audit_logs", "team_management"]) },
  enterprise: { maxProjects: Infinity, features: new Set(["core", "cli", "local_storage", "export",
                "dashboard", "cloud_sync", "analytics", "api_access", "integrations",
                "sso", "rbac", "audit_logs", "team_management",
                "on_premise", "sla", "dedicated_support", "invoice_billing"]) },
};

class LicenseManager {
  constructor(private plan: Plan = "free") {}

  hasFeature(feature: string): boolean {
    return PLAN_CONFIG[this.plan].features.has(feature);
  }

  requireFeature(feature: string): void {
    if (!this.hasFeature(feature)) {
      // Find the minimum plan that includes this feature
      const requiredPlan = (Object.entries(PLAN_CONFIG) as [Plan, any][])
        .find(([_, config]) => config.features.has(feature))?.[0] || "enterprise";
      throw new Error(
        `"${feature}" requires ${requiredPlan} plan. ` +
        `You're on ${this.plan}. Upgrade at https://yourapp.com/pricing`
      );
    }
  }
}

// Usage: const license = new LicenseManager(user.plan);
//        license.requireFeature("cloud_sync"); // throws if not on correct plan

あなたの番

1. オープンソースプロジェクトを特定する（1時間）: 自分で使うツールは何か？スクリプトで解決した問題で、適切なツールにすべきものは何か？最良のオープンソースプロジェクトは個人的なユーティリティとして始まる。

2. ライセンスを選ぶ（15分）: 収益保護のための FSL または AGPL。MIT は収益化計画のないコミュニティ貢献のためだけに。

3. コアを構築して出荷する（1〜4週間）: コアをオープンソース化する。README を書く。GitHub にプッシュする。完璧を待たない。

4. 価格階層を定義する（1時間）: Free / Pro / Team。各階層にどの機能があるか？プレミアム機能を構築する前に書き出す。

5. ローンチ（1日）: Show HN 投稿、2〜3の関連サブレディット、「Awesome」リストの PR。

レッスン 8: データプロダクトとインテリジェンス

「情報は、処理され、フィルタリングされ、コンテキストの中で配信されて初めて価値がある。」

最初の1ドルまで: 4〜8週間 継続的な時間コミットメント: 週5〜15時間 利益率: 85〜95%

データプロダクトとは何か

データプロダクトは生の情報 — パブリックデータ、研究論文、市場トレンド、エコシステムの変化 — を取り込み、特定のオーディエンスにとってアクショナブルなものに変換する。ローカル LLM が処理を担当し、あなたの専門知識がキュレーションを担当する。その組み合わせに支払う価値がある。

これはコンテンツ収益化（レッスン2）とは異なる。コンテンツは「React トレンドについてのブログ記事」だ。データプロダクトは「React エコシステムの意思決定者向けに、スコアリングされたシグナル、トレンド分析、具体的なアクショナブルレコメンデーション付きの構造化された週次レポート」だ。

データプロダクトの種類

1. キュレーテッド・インテリジェンスレポート

2. 加工済みデータセット

3. トレンドアラート

データパイプラインの構築

週刊インテリジェンスレポートを作成する完全なパイプラインを示す。これは実際の、実行可能なコードだ。ゼロコストでアイテムを処理するには、Ollama がローカルで動いている必要がある（モジュール S 参照）。

#!/usr/bin/env python3
"""
intelligence_pipeline.py — Weekly intelligence report generator.
Fetches → Scores → Formats → Delivers. Customize NICHE and RSS_FEEDS for your domain.
"""
import requests, json, time, feedparser
from datetime import datetime, timedelta
from pathlib import Path

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "llama3.1:8b"

# ── Stage 1: Fetch from RSS + HN ─────────────────────────────────

def fetch_items(feeds: list[dict], hn_min_score: int = 50) -> list[dict]:
    items = []
    cutoff = datetime.now() - timedelta(days=7)

    # RSS feeds
    for feed_cfg in feeds:
        try:
            for entry in feedparser.parse(feed_cfg["url"]).entries[:20]:
                items.append({"title": entry.get("title", ""), "url": entry.get("link", ""),
                    "source": feed_cfg["name"], "content": entry.get("summary", "")[:2000]})
        except Exception as e:
            print(f"  Warning: {feed_cfg['name']}: {e}")

    # Hacker News (Algolia API, time-filtered)
    week_ago = int(cutoff.timestamp())
    resp = requests.get(f"https://hn.algolia.com/api/v1/search?tags=story"
        f"&numericFilters=points>{hn_min_score},created_at_i>{week_ago}&hitsPerPage=30")
    for hit in resp.json().get("hits", []):
        items.append({"title": hit.get("title", ""), "source": "Hacker News",
            "url": hit.get("url", f"https://news.ycombinator.com/item?id={hit['objectID']}"),
            "content": hit.get("title", "")})

    # Deduplicate
    seen = set()
    return [i for i in items if i["title"][:50].lower() not in seen and not seen.add(i["title"][:50].lower())]

# ── Stage 2: Score with Local LLM ────────────────────────────────

def score_items(items: list[dict], niche: str, criteria: str) -> list[dict]:
    scored = []
    for item in items:
        prompt = f"""Score this item for a {niche} newsletter. Criteria: {criteria}
Title: {item['title']} | Source: {item['source']} | Content: {item['content'][:1500]}
Output JSON: {{"relevance_score": 0-10, "category": "Breaking|Tool|Research|Tutorial|Industry|Security",
"summary": "2-3 sentences", "actionable_insight": "what to DO", "key_takeaway": "one sentence"}}"""

        try:
            resp = requests.post(OLLAMA_URL, json={"model": MODEL, "prompt": prompt,
                "stream": False, "format": "json", "options": {"temperature": 0.2}}, timeout=60)
            data = json.loads(resp.json()["response"])
            if data.get("relevance_score", 0) >= 5.0:
                item.update(data)
                scored.append(item)
        except Exception:
            continue
        time.sleep(0.5)

    return sorted(scored, key=lambda x: x.get("relevance_score", 0), reverse=True)

# ── Stage 3: Generate Markdown Report ─────────────────────────────

def generate_report(items: list[dict], niche: str, issue: int) -> str:
    date_str = datetime.now().strftime('%B %d, %Y')
    report = f"# {niche} Intelligence — Issue #{issue}\n**Week of {date_str}**\n\n---\n\n"

    if items:
        top = items[0]
        report += f"## Top Signal: {top['title']}\n\n{top.get('summary','')}\n\n"
        report += f"**Why it matters:** {top.get('key_takeaway','')}\n\n"
        report += f"**Action:** {top.get('actionable_insight','')}\n\n[Read more]({top['url']})\n\n---\n\n"

    for item in items[1:12]:
        report += f"### [{item['title']}]({item['url']})\n"
        report += f"*{item['source']} | {item.get('category','')} | Score: {item.get('relevance_score',0)}/10*\n\n"
        report += f"{item.get('summary','')}\n\n> **Action:** {item.get('actionable_insight','')}\n\n"

    report += f"\n---\n*{len(items)} items analyzed. Generated locally on {date_str}.*\n"
    return report

# ── Run ───────────────────────────────────────────────────────────

if __name__ == "__main__":
    NICHE = "Rust Ecosystem"  # ← ここを変更
    CRITERIA = "High: new releases, critical crate updates, security vulns, RFC merges. " \
               "Medium: blog posts, new crates, job data. Low: peripheral mentions, rehashed tutorials."
    FEEDS = [
        {"name": "This Week in Rust", "url": "https://this-week-in-rust.org/rss.xml"},
        {"name": "Rust Blog", "url": "https://blog.rust-lang.org/feed.xml"},
        {"name": "r/rust", "url": "https://www.reddit.com/r/rust/.rss"},
    ]

    items = fetch_items(FEEDS)
    print(f"Fetched {len(items)} items")
    scored = score_items(items, NICHE, CRITERIA)
    print(f"Scored {len(scored)} above threshold")
    report = generate_report(scored, NICHE, issue=1)

    output = Path(f"./reports/report-{datetime.now().strftime('%Y-%m-%d')}.md")
    output.parent.mkdir(exist_ok=True)
    output.write_text(report)
    print(f"Report saved: {output}")

データプロダクトの配信

配信: Resend（月3,000通のメールまで無料）または Buttondown を使う。マークダウンレポートを marked で HTML に変換し、Resend のバッチ API で送信する。配信コード全体: 約15行。

データプロダクトの価格戦略:

無料プラン:     月次サマリー（ティーザー） — オーディエンスの構築
個人:          $15-29/月 — 完全な週次レポート + アーカイブアクセス
チーム:        $49-99/月 — 複数シート + 生データへの API アクセス
エンタープライズ: $199-499/月 — カスタムシグナル、専任アナリスト時間

収益予測

1ヶ月目:    10購読者 @ $15/月  = $150/月   （友人、アーリーアダプター）
3ヶ月目:    50購読者 @ $15/月  = $750/月   （オーガニック成長、HN/Reddit 投稿）
6ヶ月目:    150購読者 @ $15/月 = $2,250/月  （SEO + リファラルが効き始める）
12ヶ月目:   400購読者 @ $15/月 = $6,000/月  （確立されたブランド + チームプラン）

運用コスト:  約$10/月（メール送信 + ドメイン）
あなたの時間: 週5-8時間（ほとんど自動化、あなたが専門知識を追加）

文脈のための現実のコンテンツクリエイターベンチマーク:

• Fireship (Jeff Delaney): YouTube 登録者400万人。広告だけで年間約 $550K 以上。開発者向け、短尺コンテンツ。(出典: networthspot.com)
• Wes Bos: コース総売上 $10M 以上、有料受講者55K人。技術教育がニュースレター収入をはるかに超えてスケールできることを証明。(出典: foundershut.com)
• Josh Comeau: CSS コースの先行予約で初週に $550K。フォーカスされた高品質な技術教育がプレミアム価格を獲得することを実証。(出典: failory.com)

これらはエリートな結果だが、上記のパイプラインアプローチは彼らの多くが始めた方法だ: 一貫した、ニッチにフォーカスした、明確な価値のあるコンテンツ。

鍵: パイプラインが重労働をこなす。CPU のみの推論でも、週30〜50記事の処理はバッチパイプラインとして実用的だ。あなたの専門知識がモートだ。ドメイン知識 + キュレーション判断 + 処理インフラのあなた固有の組み合わせを持つ人は他にいない。

あなたの番

1. ニッチを選ぶ（30分）: 意見を持てるほどよく知っているドメインは何か？それがあなたのデータプロダクトのニッチだ。

2. 5〜10のデータソースを特定する（1時間）: RSS フィード、API、サブレディット、HN 検索、現在読んでいるニュースレター。これらが生の入力だ。

3. パイプラインを1回実行する（2時間）: 上記のコードを自分のニッチ向けにカスタマイズする。実行する。出力を見る。役に立つか？お金を払うか？

4. 最初のレポートを作成する（2〜4時間）: パイプラインの出力を編集する。あなたの分析、意見、「だから何」を追加する。これが支払う価値のある20%だ。

5. 10人に送る（30分）: プロダクトとしてではなく — サンプルとして。「週刊 [ニッチ] インテリジェンスレポートのローンチを検討しています。最初の号です。これは役に立ちますか？月 $15 を払いますか？」

エンジン選択: 2つの選び方

「8つのエンジンを知った。2つが必要だ。選び方はこうだ。」

意思決定マトリクス

あなた固有の状況に基づいて、これら4つの次元で各エンジンを1〜5でスコアリングしよう:

このマトリクスを埋めよう:

エンジン                     スキル  時間  速度  スケール  合計
─────────────────────────────────────────────────────────
1. デジタルプロダクト           /5     /5     /5     /5     /20
2. コンテンツ収益化            /5     /5     /5     /5     /20
3. マイクロ SaaS              /5     /5     /5     /5     /20
4. オートメーション・アズ・ア・サービス  /5     /5     /5     /5     /20
5. API プロダクト              /5     /5     /5     /5     /20
6. コンサルティング             /5     /5     /5     /5     /20
7. オープンソース + プレミアム    /5     /5     /5     /5     /20
8. データプロダクト             /5     /5     /5     /5     /20

1+1 戦略

あなたの経験レベルでは: 8年以上では、時間とともに複利になるエンジンにフォーカス: オープンソース + プレミアム、データプロダクト、またはプレミアムレートのコンサルティング ($250-500/時間)。信頼性とネットワークを持ってプレミアム価格を要求できる。アドバンテージは信頼と評判 — それを活用しよう。選んだエンジンのアンプリファイアーとして、コンテンツブランド（ブログ、ニュースレター、YouTube）の構築を検討しよう。

エンジン 1: FAST エンジン — 速度スコアが最も高いエンジンを選ぶ（タイブレーカー: 最高合計）。第5〜6週で構築するもの。目標は14日以内の収益。

エンジン 2: SCALE エンジン — スケールスコアが最も高いエンジンを選ぶ（タイブレーカー: 最高合計）。第7〜8週で計画し、モジュール E を通して構築するもの。目標は6〜12ヶ月にわたる複利成長。

相性が良い一般的な組み合わせ:

収益予測ワークシート

選んだ2つのエンジンについてこれを記入しよう:

エンジン 1 (Fast): _______________________________

  最初の1ドルまで: _____ 週間
  1ヶ月目の収益:      $________
  3ヶ月目の収益:      $________
  6ヶ月目の収益:      $________

  月間必要時間:        _____ 時間
  月間コスト:          $________

  最初のマイルストーン: $________ まで __________

エンジン 2 (Scale): _______________________________

  最初の1ドルまで: _____ 週間
  1ヶ月目の収益:      $________
  3ヶ月目の収益:      $________
  6ヶ月目の収益:      $________
  12ヶ月目の収益:     $________

  月間必要時間:        _____ 時間
  月間コスト:          $________

  最初のマイルストーン: $________ まで __________

合計予測:

  3ヶ月目合計:    $________/月
  6ヶ月目合計:    $________/月
  12ヶ月目合計:   $________/月

  月間合計時間:    _____ 時間
  月間合計コスト:  $________

本音: これらの予測は間違っているだろう。それで良い。ポイントは正確さではなく — 構築を始める前に計算を考え抜くことを強制することだ。週30時間を要求するが $200/月しか生まない収益エンジンは悪い取引だ。時間を投資する前に、それを紙の上で確認する必要がある。

プラットフォームリスクと多角化

すべての収益エンジンは、自分がコントロールしないプラットフォームの上に座っている。Gumroad は料金体系を変更できる。YouTube はチャンネルの収益化を停止できる。Vercel はアフィリエイトプログラムを終了できる。Stripe はレビュー中にアカウントを凍結できる。これは仮定の話ではない — 定期的に起きている。

40%ルール: 収入の40%以上を単一のプラットフォームに依存させてはならない。Gumroad が収益の60%を生み出していて、彼らが手数料を5%から15%に一夜にして引き上げたら（2023年初頭に実際に発表して後で撤回した）、マージンが崩壊する。YouTube が収入の70%で、アルゴリズム変更で視聴数が半減したら、困ったことになる。

プラットフォームリスクの実例:

パターン: プラットフォームは自社の成長のために最適化し、あなたのためではない。プラットフォームのライフサイクルの初期には、供給を引き付けるためにクリエイターを補助する。十分な供給が集まったら、価値を抽出する。これは悪意ではない — ビジネスだ。あなたの仕事は、それに驚かされないこと。

プラットフォーム依存度監査:

四半期ごとにこの監査を実行しよう。各収益ストリームについて答える:

プラットフォーム依存度監査

ストリーム: _______________
依存しているプラットフォーム: _______________

1. このストリームの収益の何パーセントがこのプラットフォームを通じて流れているか？
   [ ] <25%（低リスク）  [ ] 25-40%（中程度）  [ ] >40%（高 — 多角化すべき）

2. 30日以内に代替プラットフォームに移行できるか？
   [ ] はい、代替が存在し移行は簡単
   [ ] 部分的に — いくらかのロックイン（オーディエンス、評判、統合）
   [ ] いいえ — 深くロックインされている（独自フォーマット、データエクスポートなし）

3. このプラットフォームには不利な変更の履歴があるか？
   [ ] 有害な変更の履歴なし  [ ] 軽微な変更  [ ] 重大な不利な変更

4. 顧客との関係を所有しているか？
   [ ] はい — メールアドレスを持っており、直接顧客に連絡できる
   [ ] 部分的に — 一部の顧客は見つけられるが、一部はできない
   [ ] いいえ — プラットフォームがすべての顧客アクセスを制御

アクション項目:
- >40%の依存度: 今月中に代替を特定しテストする
- データエクスポートなし: 可能なものすべてを今すぐエクスポートし、月次リマインダーを設定
- 顧客との関係を所有していない: すぐにメール収集を開始

エンジン別の多角化戦略:

プラットフォーム多角化の黄金律: 顧客に直接メールを送れないなら、顧客を持っているのではない — プラットフォームの顧客を持っている。どのエンジンを運用するにしても、初日からメールリストを構築しよう。

アンチパターン

これらをやってはいけない:

1. 3つ以上のエンジンを選ばない。 最大は2つ。3つは注意を分散させすぎて、何もうまくいかない。

2. 遅いエンジンを2つ選ばない。 両方のエンジンが収益まで8週間以上かかるなら、結果を見る前にモチベーションを失う。少なくとも1つのエンジンは2週間以内に収益を生むべきだ。

3. 同じカテゴリのエンジンを2つ選ばない。 マイクロ SaaS と API プロダクトはどちらも「プロダクトを構築する」— 多角化していない。プロダクトエンジンとサービスエンジンまたはコンテンツエンジンを組み合わせよう。

4. 計算を省略しない。 「価格設定は後で考える」は、運用コストが稼ぎを上回るプロダクトを作る道だ。

5. 最も印象的なエンジンに最適化しない。 コンサルティングは華やかではない。デジタルプロダクトは「革新的」ではない。しかしお金を稼ぐ。Twitter で見栄えが良いものではなく、自分の状況に合うものを選べ。

6. プラットフォーム集中を無視しない。 上記のプラットフォーム依存度監査を実行しよう。単一のプラットフォームが収益の40%以上をコントロールしているなら、新しいエンジンを追加する前に多角化を優先すべきだ。

4DA との統合

4DA とモジュール R のつながり:

4DA のシグナル検出は、収益エンジンが埋める市場のギャップを見つける。スターターキットのないトレンドフレームワーク？構築しよう（エンジン1）。チュートリアルのない新しい LLM テクニック？書こう（エンジン2）。移行ガイドのない依存関係の脆弱性？作成して課金しよう（エンジン1、2、または8）。

4DA の get_actionable_signals ツールは、コンテンツを緊急度（戦術的 vs. 戦略的）と優先度で分類する。各シグナルタイプは自然に収益エンジンにマッピングされる:

シグナル分類	優先度	最適な収益エンジン	例
戦術的 / 高優先度	緊急	コンサルティング、デジタルプロダクト	新しい脆弱性が公開された — 移行ガイドを書くか修復コンサルティングを提供
戦術的 / 中優先度	今週	コンテンツ収益化、デジタルプロダクト	トレンドのライブラリリリース — 最初のチュートリアルを書くかスターターキットを構築
戦略的 / 高優先度	今四半期	マイクロ SaaS、API プロダクト	複数のシグナルにまたがる新興パターン — 市場が成熟する前にツーリングを構築
戦略的 / 中優先度	今年	オープンソース + プレミアム、データプロダクト	テクノロジー領域のナラティブシフト — オープンソース作業やインテリジェンスレポートでエキスパートとしてポジショニング

get_actionable_signals と他の 4DA ツールを組み合わせてさらに深く:

• daily_briefing — AI 生成のエグゼクティブサマリーが毎朝最も優先度の高いシグナルを浮上させる
• knowledge_gaps — プロジェクトの依存関係のギャップを発見し、それらのギャップを埋めるプロダクトの機会を明らかにする
• trend_analysis — 統計パターンと予測がどの技術が加速しているかを示す
• semantic_shifts — 技術が「実験的」から「本番環境」の採用に移行する時を検出し、市場タイミングをシグナリング

この組み合わせがフィードバックループだ: 4DA が機会を検出する。STREETS が実行のプレイブックを提供する。収益エンジンがシグナルを収入に変える。

モジュール R: 完了

4週間で構築したもの

このモジュールの最初の時点に戻ろう。インフラ（モジュール S）と防御力（モジュール T）があった。今、以下を手に入れている:

1. 収益を生む稼働中のエンジン 1（または数日以内に収益を生むインフラ）
2. エンジン 2 の詳細計画 — タイムライン、収益予測、最初のステップ付き
3. 実際のデプロイ済みコード — アイデアだけでなく、稼働中の決済フロー、API エンドポイント、コンテンツパイプライン、またはプロダクトリスティング
4. 新しい機会が現れた時に参照できる意思決定マトリクス
5. ターゲットに到達するために必要な販売数、クライアント数、購読者数を正確に教えてくれる収益の計算

キーデリバブルチェック

モジュール E（実行プレイブック）に進む前に確認:

• [ ] エンジン 1 は稼働中。何かがデプロイされ、出品され、または購入/雇用可能な状態。
• [ ] エンジン 1 は少なくとも $1 の収益を生成した（または7日以内に $1 に至る明確なパスがある）
• [ ] エンジン 2 は計画済み。マイルストーンとタイムライン付きの文書化された計画がある。
• [ ] 意思決定マトリクスは記入済み。なぜこの2つのエンジンを選んだか理解している。
• [ ] 収益予測ワークシートは完成。1、3、6、12ヶ月目のターゲットを把握している。

これらのいずれかが未完了なら、時間をかけよう。モジュール E はこのすべての上に構築される。稼働中のエンジン 1 なしで先に進むのは、存在しないプロダクトを最適化しようとするようなものだ。

次に来るもの: モジュール E — 実行プレイブック

モジュール R はエンジンを与えた。モジュール E はそれらの運用方法を教える:

• ローンチシーケンス — 各エンジンの最初の24時間、最初の週、最初の月に正確に何をすべきか
• 価格心理学 — なぜ $49 が $39 より売れるのか、そして値引きをすべき時（ほぼ決してない）
• 最初の10人の顧客を見つける — 各エンジンタイプに対する具体的でアクショナブルな戦術
• 重要な指標 — 各段階で何を追跡し、何を無視すべきか
• ピボットのタイミング — エンジンが機能していないことを告げるシグナルと、その時にすべきこと

エンジンは構築済みだ。今度はそれを運転することを学ぶ。

あなたのリグ。あなたのルール。あなたの収益。