AI オートメーションはいま、AI 業界全体のなかで静かに「最も ROI の高いスキル」になっている。
問題は、この分野に入ってくるほとんどの人が同じやり方で行き詰まっている、ということだ。
- 初日に Python チュートリアルを開いて、2 週目で壁にぶつかり、ノーコードツールには一度も触らない人。
- 8 時間の YouTube チュートリアルに迷い込み、実在のビジネス向けのワークフローを一度も作らない人。
- ベーシックなワークフローや API の仕組みも分からないうちから「AI エージェント」に直行する人。
結果はいつも同じだ。中途半端なデモが並んだフォルダと、ゼロ件の有料顧客。
ほとんど誰も初心者に伝えない真実はこれだ:
「AI オートメーションビルダー (AI Automation Builder) になるために、ソフトウェア開発者になる必要はない」
「機械学習を学ぶ必要もない」
「モデルをファインチューンする必要もない」
あなたがやるべきは、企業がすでに使っているツール群に AI を繋ぎ、彼らがいま人間に金を払ってやらせている、退屈で反復的な仕事を自動化することだ。
つまり、学ぶべきは:
- リアルなビジネスツールを横断する、エンドツーエンドの自動化ワークフローを作ること
- CRM、メール、ドキュメント、サポート系に AI を配線すること
- 反復的な人間タスクを、信頼できる AI 駆動のパイプラインに変えること
- 実クライアントのトラフィックに耐える自動化を出荷すること
- 月 $500〜$5,000 を請求し、計測可能な ROI を提供すること
このガイドは、あなたに実用的な 6 ヶ月ロードマップを渡すために作られた。
記事は 1 万語を超えるので、読むのに数時間かかるだろう。
だが、真の価値は、「学ぶ必要のあるスキル」ごとにリソースと「次にすべきこと」の明確な説明が添えてあるところにある。
これで 6 ヶ月以内に「雇える AI Automation Builder」のレベルに達し、最初の 1〜2 ヶ月のうちから収入が発生し始めることが可能になる。
[ さあ記事を読んでいこう ] ⬇️
まず読め: ノンテク路線 vs デベロッパー路線
このロードマップは 2 種類の人間に対して機能する。開始前にどちらなのかを選ぶ必要がある。
ノンテク路線（デフォルト — 読者の大半はこちら）
コードを書いたことがない、あるいは少し知っていても開発者にはなりたくない人。あなたの超能力は「ノーコードツール（特に n8n）」で、それをシンプルなノードを介して AI に繋ぐ。Python を 1 行も書かずに、本物のオートメーションを作って売ることもできる。これが最初の有料顧客までの、最速かつ最も現実的な道だ。
デベロッパー路線（オプショナルなアドオン）
すでにコードを書く、あるいは真剣に学びたい人。同じロードマップを辿りつつ、Python、LangGraph、カスタムバックエンドのピースも拾っていく。後々、より大きな契約や複雑な仕事を解放してくれるが、これは完全にオプショナルである。
以下の月別セクションは、まずノンテク路線向けに書かれている。各セクションの最後に、その方向へ進みたい人向けの追加事項をまとめた「デベロッパー路線」ボックスがある。要らなければ罪悪感なしでスキップしてよい。
ルールは 1 つ: レーンを選んだらスイッチするな。「ノーコードを学ぶ」と「Python を学ぶ」の間で 6 ヶ月間フラフラ往復する人は、結局どちらも身につかない。
AI Automation Builder は実際には何をする仕事か？
「AI 自動化」と聞くと、多くの人はチーム全体を置き換えるようなピカピカの AI エージェントを思い浮かべる。
現実は、もっと退屈で、もっと儲かるものだ。
あなたは、金のかかる反復的なビジネスプロセスを、人間のお守りなしに 24/7 回り続ける AI 駆動ワークフローとして作り直す。
具体的には通常、以下を含む:
- LLM を、企業がすでに使っているツール（CRM、メール、Slack、Notion、DB）に接続する
- あるシステムのトリガーを、別のシステムのアクションへ変換する
- これまで人手で行っていたワークフローに AI の意思決定を組み込む
- 人間のトリアージ、分類、ルーティング作業を LLM 呼び出しで置き換える
- 社内ドキュメントの上に社内ナレッジ bot を構築する
- リード獲得、アウトリーチ、コンテンツ、サポートのパイプラインを自動化する
- これらのシステムをモニタリングし、ノンテクなクライアントに引き渡す
つまり実務的には、AI Automation Builder は以下の間に立つ仕事だ:
- ワークフロー自動化（n8n、Make、Zapier）
- 応用 AI（LLM、プロンプト、シンプルなエージェント）
- ビジネスプロセス・コンサルティング（何を自動化する価値があるかの見極め）
- 軽いテクニカルな糊付け作業（ドキュメントを読む、小さな修正、デバッグ）
これが、いまこのロールが爆発的に伸びている理由である。
2026 年のあらゆる SMB、エージェンシー、SaaS 企業は、人間に高すぎるコストで回させている 20 個の反復的ワークフローを抱えている。
彼らはリサーチャーは要らない。ファインチューナーも要らない。彼らが欲しいのは、現場に入って出血箇所を見つけ、初月で元が取れるワークフローで止血できる人間だ。
だからこのロードマップは、プロダクト作りではなく「ビジネスアウトカムを出荷すること」に寄せて書かれている。
本物の CRM、本物のインボックス、本物のコンテンツパイプラインに AI を配線できるなら、あなたはすでに LinkedIn で「AI エンジニア」を名乗っている人間の 90% よりも雇用価値が高い。
また、始める前に、少しモチベーションを与えておこう:
- いまだに自動化を全く導入していない企業が 3.1 億社も存在する！！
- 世界全体での企業数は約 3.6 億社（このうち自動化を部分的にでも導入しているのは 5,000 万社のみ）。
- そして、もっとも重要なこと: この世界で、この種のサービスをまともに提供できる人間は合計でわずか 100 万人程度しかいない。
80 億超の人がこの惑星に住んでいるなかで、これは本当に小さな数字だ。いま、我々は極めて早期にいる！！！
以下は、これらの自動化にどれくらいの料金を設定できるかの目安。
- $500〜$5k / 月: 企業向けの自動化ワークフロー構築
- $1k〜$3k / 月: リード獲得システムの自動化
- $500〜$2k / 月: AI 駆動のコンテンツパイプライン
- $1k〜$4k / 月: AI エージェントによるカスタマーサポート自動化
- $500〜$2k / 月: 自動化されたレポーティング・データダッシュボード
- $500〜$2k / 月: AI 駆動のコールドアウトリーチ
- $1k〜$3k / 月: 社内向けオートメーションアシスタント構築
- $500〜$1.5k: チーム向け AI ワークフロー研修
- $300〜$1k: 1:1 オートメーションコンサルティング
* これはフリーランス・外注プラットフォームや、専門的にやっている友人たちと共有した平均値である。
* つまり、実際にはもっと高くなることもある（会社規模や、何人リストラしたいかで変わる 笑）。
さあ始めよう！！！
⏩--------------------------------------------------------------------⏪
Month 1: n8n で最初のワークフローを作る
今月のゴール: n8n で最初の本物のオートメーションを作る。API と webhook の概念を理解する。LLM に自分の望む動きをさせるのに十分なプロンプト術を身につける。
今月は Python は学ばない（デベロッパー路線の人を除く）。代わりに、今後 6 ヶ月あなたの支払いを賄ってくれるツール 1 つを学び、ドキュメントを読めるだけの語彙を身につける。
学ぶこと:
1. ノーコードプラットフォームを 1 つだけ選んで深掘る（ここから始めよ）
Month 1 で最重要の決断だ。ツールは 1 つだけ選ぶ。深く学ぶ。他のツールは、根本概念を理解したあとに週末でキャッチアップできる。
どれを選ぶか:
- n8n: このキャリアを本気でやる気なら、これ一択。オープンソース、無料枠が寛大、AI ノードの質が業界一、セルフホスト可能、実際に稼いでいる自動化エージェンシーはだいたいここにいる。このロードマップ全体のデフォルト推奨。
- Make（旧 Integromat）: もっとも美しいビジュアル UI が欲しいならこれ。エージェンシーのクライアントワークや複雑な分岐に強い。
- Zapier: すでに Zapier を使っているノンテクなクライアント向けの MVP をサッと組みたいときにのみ選ぶ。スケールさせると本格運用には高すぎる。
私のおすすめ: n8n。この記事は特に断りがない限り n8n を前提にしている。
リソース:
1. n8n 公式ドキュメント（無料） https://docs.n8n.io/
「Quickstart」から始めて、コアコンセプトを全部こなせ。ドキュメントの質は本気で良い。
2. n8n Academy（無料） https://docs.n8n.io/courses/
ビギナーから上級まで、AI 統合を含むワークフローパターンを公式無料コースで網羅。Month 1 における最良のリソース。
3. Productive Dude（YouTube、無料） https://www.youtube.com/@productivedude
n8n 特化、実践的、初心者に優しい。
4. Nick Saraev（YouTube、無料） https://www.youtube.com/@nicksaraev
「自動化で稼ぐ」ことに特化。S/N 比が高い。
5. Make Academy（Make を選んだ人向け、無料） https://academy.make.com/
フォーカスするポイント:
- トリガー（cron、webhook、アプリイベント）と アクション の違い
- ステップ間をデータがどう流れるか
- エラーハンドリングとフォールバック経路
- ネイティブ統合がない場面での HTTP Request ノードの使い方
- 実行ログの読み方とデバッグ
- 組み込みの OpenAI / AI Agent ノード（Month 2 で使う）
練習: まずは自分の生活で何かを自動化する。マジでやれ。Gmail 添付を Google Drive に自動保存、商品価格を毎日スクレイプして Google Sheet に書く、特定キーワードをメール受信時に自分の Telegram に送る、など。顧客向けに作る前に、リスクの低い場面でまず筋肉をつける。
2. API、webhook、JSON（コードではなく「語彙」として）
あなたが作るすべての自動化は、API を介して 2 つのシステムを繋ぐ。API を「書ける」必要はない。ドキュメントを読むために「理解する」必要がある。webhook とは何か、JSON はどんな見た目か、を。
リソース:
1. What is a Webhook?（Zapier blog、無料） https://zapier.com/blog/what-are-webhooks/
ノンデベロッパー向けの、webhook のベスト入門記事。
2. HTTP basics — MDN Web Docs（無料） https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
Web が自身をどう話しているかの最も明快な無料解説。
3. Postman Learning Center（無料） https://learning.postman.com/
Postman は API テストのユニバーサルツール。本物の API に触る前にまず「Getting Started」をこなせ。ボタンを押すだけで、コードは書かない。
4. REST API Tutorial（無料） https://restfulapi.net/
短く、実践的、余計な理論なし。
フォーカスするポイント:
- GET / POST / PUT / DELETE（それぞれ何のため？）
- JSON の見た目（中括弧、キー/値、配列）
- HTTP ステータスコード: 200（OK）、401（認証失敗）、404（未検出）、429（レート制限）、500（壊れた）
- API キーと Bearer トークンの概念（貼るだけ、作るわけではない）
- Webhook vs ポーリング（使い分け）
- レート制限とヒット時に何が起きるか
練習: Postman で無料の公開 API を呼ぶ（例: https://api.github.com/users/torvalds）。JSON が返ってくるのを見る。次に、同じ呼び出しを n8n の HTTP Request ノードで再現する。比較する。この 1 つの練習で、ノンデベロッパーの人にとって API のミステリーの 50% が解ける。
3. パニックにならずに API ドキュメントを読む
どんな本物の自動化も、いずれは API ドキュメントを読む必要が出てくる。これが「出荷する人」と「自分のユースケースに完全一致する YouTube チュートリアルを永遠に待つ人（スポイラー: 存在しない）」を分けるスキルだ。
リソース:
1. How to Read API Documentation — Postman Blog（無料） https://blog.postman.com/how-to-read-api-documentation/
API ドキュメントの構造を短く実践的に解説。
2. Stripe API ドキュメント（無料、クラス最高峰の例） https://docs.stripe.com/api
Stripe を使わないとしても、これは読む価値がある。API ドキュメント設計のゴールドスタンダード。
フォーカスするポイント:
- 「Authentication」のセクションを常に最初に見つける
- Base URL、エンドポイントパス、メソッド、必須パラメータの特定
- リクエスト/レスポンスのサンプルを読む
- レート制限とページネーションのパターンを見つける
- ワークフローに組み込む前に、Postman で 1 エンドポイントだけテストする
練習: あなたがすでに使っているツール（Notion、Airtable、Slack、HubSpot）を 1 つ選び、Postman から成功する API コールを 1 回だけやる。1 回でいい。何かのリストを取ってくる。そして止める。
4. 基本的なプロンプトエンジニアリング
プロンプトの魔術師になる必要はない。基礎を理解する必要がある: system プロンプト vs user プロンプト、具体性、例示、構造化出力の強制（ワークフローの後続ステップが使えるように）。
リソース:
1. Anthropic のインタラクティブ・プロンプトエンジニアリング・チュートリアル（無料、GitHub） https://github.com/anthropics/prompt-eng-interactive-tutorial
ハンズオンのプロンプト入門として最良。演習付きの章立て。
2. OpenAI Prompt Engineering Guide（無料） https://platform.openai.com/docs/guides/prompt-engineering
3. Learn Prompting（無料、包括的） https://learnprompting.org/
基礎から上級までの完全無料コース。
4. @EXM7777 の Advanced Prompt Engineering 記事（無料） https://x.com/EXM7777/status/2011800604709175808
フォーカスするポイント:
- system プロンプト vs user プロンプト
- 「賢さ」より「具体性」が勝つ理由
- 例示 (few-shot プロンプティング)
- 構造化出力（JSON、CSV、特定フォーマット）を要求すること — これこそ自動化の中で AI が使い物になるための鍵
- 推論が必要なタスクでの chain-of-thought
5. LLM が実際に得意なこと（そしてどこで失敗するか）
これはクライアントの前で恥をかかないためのセクション。AI を「使わない方がいいタイミング」を知ることは、「使うべきタイミング」を知ることと同じくらい価値がある。
リソース:
1. Andrej Karpathy の YouTube トーク（無料） https://www.youtube.com/@AndrejKarpathy
LLM が真に価値を出す場所に関する最も明快な思考。
2. Simon Willison のブログ（無料） https://simonwillison.net/
応用 AI で最も実践的な声。直近の投稿を読め。
暗記すべき:
- 得意: 分類、要約、抽出、翻訳、ドラフト、明確な基準のある意思決定ツリー
- 不得意: 厳密な計算、リトリーバルなしのリアルタイムデータ、完全な整合性を要するタスク、安全に関わるもの全般
6.（デベロッパー路線のみ）自分を詰まらせないだけの Python
ノンテク路線の人はこのセクションを飛ばしてよい。
デベロッパー路線を行く場合、ドキュメントを読み、小さなスクリプトを書き、ノーコードが限界に達したときに糊を塗れるだけの Python を学ぶ。シニア開発者を目指すわけではない。
リソース:
1. Python for Everybody（Coursera、audit 無料） https://www.coursera.org/specializations/python
2. freeCodeCamp Python Course（YouTube、無料） https://www.youtube.com/watch?v=rfscVS0vtbw
3. Automate the Boring Stuff with Python（無料オンライン書籍） https://automatetheboringstuff.com/
アプリではなくタスク自動化を目的にする人向け。
フォーカス: 変数、ループ、条件分岐、関数、リスト、dict、JSON、ファイル読み込み、requests ライブラリ、try/except、ターミナルからのスクリプト実行。
Month 1 マイルストーン:
今月の終わりまでに、以下ができるようになっているべき:
- 自分の生活の問題を解く 3〜5 ステップのワークフローを n8n で作れる
- webhook、API キー、JSON、HTTP ステータスコードを平易な言葉で説明できる
- 初見の API ドキュメントを読み、Postman でテスト呼び出しを成功させられる
- 一貫した構造化出力を返す、明確なシステムプロンプトを書ける
- LLM が得意なタスク 5 個、恥をかくタスク 5 個を挙げられる
ここまで達成できれば、「AI 業界に入ろう」としている人の 80% よりもすでに先にいる。
⏩--------------------------------------------------------------------⏪
Month 2: AI をワークフローに埋め込む
今月のゴール: ChatGPT を手動で使うのをやめる。n8n ワークフロー内で AI を自動的に走らせ、実際のトリガーに反応させ、意思決定させ、実システムに書き込ませる（あなたがボタンを押さなくても）。
Month 2 終了時には、AI を内包したリアルなワークフローが 3〜5 個あり、最初の有料案件がどういう姿になるかが明確になっているはずだ。
これが「ノーコードユーザー」から「AI Automation Builder」に変わる月だ。
学ぶこと:
1. n8n の AI ノード（デフォルト路線）
n8n には OpenAI、Anthropic、そして完全な AI Agent ノードがビルトインされている。あなたが出荷するものの 90% では、Python に触れなくてよい。AI ノードを普通のステップのようにワークフローにドロップするだけだ。
リソース:
1. n8n AI Nodes & LangChain Docs（公式、無料） https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
AI セクションを全部通しで歩け。n8n チームはノーコードキャンバス上で AI を使えるようにするために、とてつもない仕事をしている。
2. n8n Academy: AI Workflows Course（無料） https://docs.n8n.io/courses/
専用の AI トラックがある。やれ。
3. n8n AI テンプレート（無料） https://n8n.io/workflows/?categories=AI
100+ のリアルでインポート可能なテンプレート。どんなチュートリアルより良い（1 個インポートして、動かして、どう配線されているかを見る）。
フォーカスするポイント:
- OpenAI / Anthropic ノードをワークフローにドロップする
- 前のステップから入ってきたデータをプロンプトへ動的に渡す（n8n の式）
- AI レスポンスをパースして、後続ステップで特定フィールドを使う
- プロンプトを中央管理する（Notion doc または専用の n8n サブワークフロー）。深く掘らずに編集できるように。
- AI をインラインで使うべき場面と、単純な IF ノードで十分な場面を見分ける
練習プロジェクト: Google Form を監視し、新しい回答を LLM に送って分類（urgent / normal / spam）し、カテゴリに応じて Airtable の別テーブルに書き込むワークフローを作る。コードなし。純粋に n8n のみ。
2. コアスケルトン: Trigger → AI Decision → Action → Output
あなたが作る AI 自動化はほぼすべて、次のスケルトンに収まる:
Trigger（何かが起きる）→ AI 判断（分類・抽出・生成）→ Action（システムに書き込む）→ Output（通知 / ログ / 確認）
このスケルトンをマスターすれば、「エージェント」に手を出さずとも実世界の自動化の 80% はすでに作れる。
リソース:
1. Anthropic: Building Effective Agents（無料） https://www.anthropic.com/research/building-effective-agents
「Workflow patterns」セクションを読む。プロンプトチェーン、ルーティング、並列化を明確な図で解説。いまはエージェントフレームワーク関連の話は無視してよい。
2. n8n AI テンプレート（無料） https://n8n.io/workflows/?categories=AI
このスケルトンに合う 3 個のテンプレートを選び、分解して読む。
フォーカスするポイント:
- ノードを 1 個もドラッグする前に、紙の上でワークフローをスケッチする
- 判断 1 個につき LLM コール 1 回（全部を 1 個の巨大プロンプトで処理しようとしない）
- 冪等性（同じワークフローを 2 回走らせても二重処理しない）
- IF ノード（決定論的）と AI ノード（曖昧）の使い分け
練習プロジェクト: 受信メールを読み（Gmail トリガー）、AI で {support, sales, personal, spam} に分類し、各カテゴリを別のアクション（チケット作成、CRM リード作成、転送、アーカイブ）にルーティングする。エージェントは使わない。綺麗なチェーンだけ。
3. エラーハンドリングとフォールバック（「クライアントが本当に金を払う」部分）
あなたのワークフローは本番で壊れる。API は落ちる。レート制限に達する。LLM は malformed な JSON を返す。クライアントはあなたに「90% の確率で動くもの」に金を払っているのではない。「99.9% 動き、残りの 0.1% を優雅に処理できるもの」に金を払うのだ。
リソース:
1. n8n: Error Handling & Error Workflows（無料） https://docs.n8n.io/flow-logic/error-handling/
任意のワークフローの任意の失敗をキャッチする、グローバルなエラーハンドラの作り方。これは n8n の本番運用における最良の機能。
2. n8n: Retry on Fail（無料、同ページ）
あらゆるノードに内蔵。早めに覚えろ。
3. Nate Herk: Workflow for Unlimited Error Handling（無料） https://www.youtube.com/watch?v=bTF3tACqPRU
起こりうる失敗の 95% を文字通り解説している。
フォーカスするポイント:
- すべての API 呼び出しノードで「Retry On Fail」を有効化
- すべてのワークフローの失敗をキャッチする中央エラーワークフローを構築
- LLM が malformed な JSON を返したら再プロンプトする
- クリティカルなワークフローが壊れたら Slack か Telegram で自分に通知する
- フォールバック: プライマリモデルがダウンなら、セカンダリを試す
4. コスト感覚: トークン、料金、AI のオーバーキル判定
トークンコストを理解せずに AI 自動化を出荷する = クライアントプロジェクトで $3,000 のサプライズ請求が来る。このスキルは最初の 1 ヶ月で元が取れる。めちゃくちゃ重要（私はこれで $400 失った）。
リソース:
1. OpenAI Pricing（無料） https://openai.com/api/pricing
2. Anthropic Pricing（無料） https://www.anthropic.com/pricing
3. OpenAI Tokenizer（インタラクティブ、無料） https://platform.openai.com/tokenizer
任意のテキストを貼って、トークン数が何か正確に見る。常用する。
暗記すべき:
- 入力トークンは安く、出力トークンは高い（通常 4〜5 倍）
- 分類、ルーティング、抽出には安いモデルで「十分」
- 高いモデルはクリエイティブ生成や複雑な推論のときだけ使う
- クライアントに出荷する前に、ワークフローの月次コストを計算する
練習: 1 日 1,000 件のメールを処理するワークフロー（各メールで安いモデルで 1 回分類 + 中位モデルで 1 回ドラフト生成）の月次コストを計算せよ。この計算に慣れる（クライアントがあなたを信頼するのは、これができるからだ）。
5.（デベロッパー路線のみ）Python から OpenAI / Anthropic を呼ぶ
ノンテク路線の人はスキップ。
デベロッパー路線なら、n8n でやっているのと同じ LLM 呼び出しを Python からもできるようにする。n8n でできないことをしたい時や、クライアントが完全カスタムバックエンドを欲しがるときに有用になる。
リソース:
1. OpenAI API Quickstart（公式、無料） https://platform.openai.com/docs/quickstart
2. Anthropic API Quickstart（公式、無料） https://docs.anthropic.com/en/docs/get-started
3. OpenAI Cookbook（公式、無料） https://cookbook.openai.com/
よくあるパターン毎の実行可能な Notebook。
フォーカス: API キーは環境変数へ（コードに埋めない）、chat completions、system vs user プロンプト、自動化では temperature=0、モデル選択、function / tool calling。
Month 2 マイルストーン:
今月終わりまでに以下ができるようになる:
- 任意の n8n ワークフローに、自信を持って AI をドロップできる
- 一般的なビジネスタスクに対して、綺麗な trigger → AI → action → output チェーンを設計できる
- API 失敗、悪い JSON、レート制限を、ワークフローをクラッシュさせずにハンドリングできる
- 任意の AI ワークフローのデプロイ前月次コストを見積もれる
- 自分のワークフローを指して「この構築にはビジネスが金を払う」と、本気で言える
⏩--------------------------------------------------------------------⏪
早期マネタイゼーション: 最初の $500 案件 (Month 2〜3)
これは、インターネット上の「6 ヶ月で AI の X になる」記事からほぼ例外なく欠落しているセクション。
ほとんどのガイドは Month 6 になってからフリーランスを勧める。遅すぎる。Month 2 か Month 3、つまり複製可能な「固い 1 個のワークフロー」を持った瞬間から、稼ぎ始めることができるし、始めるべきだ。
ケーススタディ 10 件のポートフォリオなんて要らない。動く 1 個のワークフロー、3 分の Loom ウォークスルー、そして 2 週間ほどセールス会話でぎこちなくなる覚悟があれば始められる。
最初の有料クライアントを見つける場所:
1. Upwork（最速、ビギナー向けに最適） https://www.upwork.com/
プロフィール名を「AI Automation Builder」や「n8n Automation Specialist」に。Zapier / Make / n8n / automation / AI workflow タグの案件に応募する。最初の 2〜3 件は時給 $30〜$50 にしておく。レートで揉めるな、レビューを積め。
2. Fiverr（プロダクト化されたオファー） https://www.fiverr.com/
「n8n で AI リード選別ワークフローを作ります $200」のような固定価格オファーを 2〜3 件作る。Fiverr は具体性を評価する。タグで AI automation をしっかり仕込む。
3. Contra（レートが良い、競合が少ない） https://contra.com/
底辺価格競争のないフリーランス。$500〜$2,000 のプロジェクトに向く。
4. n8n テンプレートマーケットプレイス（無料のインバウンドリード） https://n8n.io/creators/
コミュニティに無料テンプレートを公開する。インポートした人からカスタマイズ相談の DM が来る。この業界で最も安いリード獲得チャネル。
5. 自分の X と LinkedIn
作った全ワークフローを投稿する。キャンバスのスクリーンショット、2 分の Loom、問題解決の短いキャプション。Month 3 までにインバウンド DM が来る。約束する。
最初の案件で売るべきもの:
「自動化コンサル」を売るな。「AI 戦略」を売るな。時間を売るな。以下の 1 つを売れ:
- リード選別 bot: $300〜$500。フォーム送信 → AI が ICP に対してスコアリング → 高スコアは CRM or Slack へ
- メールトリアージアシスタント: $300〜$500。受信メールを AI が分類 → 自動返信 or 適切な担当者へ
- 会議ノート → CRM: $400〜$700。会議トランスクリプト → AI がアクションアイテムと CRM フィールド更新を抽出 → HubSpot に書き込み
- コンテンツ再利用器: $250〜$400。1 本の長文投稿 → AI が X / LinkedIn / ニュースレター向けのバリアント生成 → 承認用に Notion にドラフト投下
この 4 つはすべて週末で n8n で作れる。すべてビジネスが喜んで金を払う対象だ。
各案件で納品すべきもの（☆5 レビューが取れる内容）:
- n8n ワークフロー本体（インポートできるよう JSON エクスポート）
- 3〜5 分の Loom ウォークスルー
- 1 ページの Notion ドキュメント: 何をするか、監視方法、壊れたときの対応
- 引き渡し後 7 日間の無料サポート
これを全部やれば、オートメーションビルダーと仕事したことのないクライアントから ☆5 レビューが取れる。そのソーシャルプルーフが Month 4〜5 の $1,000+ 案件を解放する。
メンタルルール:
準備ができたと感じる前に案件を取れ。この業界でマジで稼いでいる友人は全員、まだ詐欺師みたいな気分でいるうちに最初の案件を取っている。唯一の抜け道は、会話を 1 件ずつ重ねることだけだ。
⏩--------------------------------------------------------------------⏪
Month 3: 1〜2 個の再利用可能なサービスワークフローを構築する
今月のゴール: 実在のビジネス問題を解く、洗練された再利用可能な自動化を 1〜2 個作る。軽いカスタマイズで複数クライアントに再販できるもの。
重要な警告: このリストの 6 ユースケースを 1 ヶ月で全部作ろうとするな。ビギナーが燃え尽きる典型パターンだ。1〜2 個を選んで深く掘る。稼ぎ始めるには「売れるサービス」が 1 個あれば十分、本格的なレバレッジのためには 2 個で足りる。
今月の終わりには、3 分でデモでき、セールスページに値段を載せられるワークフローが 1〜2 個あるはずだ。
どう 1〜2 個を選ぶか？
- どれが一番面白そうか？（気合いの入り方が違う）
- どれのビジネス文脈を自分がすでに理解しているか？
- どれの対象ツールに無料アクセスがあるか？
- いま Upwork で一番需要があるのはどれか？（検索して確認）
考えすぎずに選べ。以下は業界で最も需要の高い 6 ユースケース。いま 1〜2 個、残りは後で戻ってくる。
Use case 1: リード獲得オートメーション（最も需要が高い）
2026 年、AI 自動化のリクエスト No.1 はリードジェン。すべての B2B 企業は、より多くの有望リードと、より少ない SDR を求めている。
リソース:
1. Apify（無料枠） https://apify.com/
スクレイパーの最良プラットフォーム。LinkedIn、Google Maps、Crunchbase 向けの事前構築アクターが数千。
2. Clay（有料、トライアル有り） https://www.clay.com/
エンリッチメントの業界標準。クライアントが使っているので学ぶ価値あり。
3. Apollo.io API（無料枠） https://docs.apollo.io/
4. Hunter.io API（無料枠） https://hunter.io/api-documentation
メール発見と検証。
5. Phantombuster（有料、トライアル有り） https://phantombuster.com/
LinkedIn、Twitter、Instagram 向けの事前構築スクレイパー。
作るワークフロー: 企業ドメインリスト → ウェブ＋LinkedIn をスクレイプ → 連絡先情報でエンリッチ → AI で自分の定義した ICP に対してスコア → 上位リードを CRM / Google Sheet に書き込み。「Lead Qualification Pipeline — $1,500 初期 + $500/月」として販売可能。
あるいは、これをあなた自身が作る必要すらない。私がすでに代わりに作っているからだ。
私はいま自分のプロダクト「Close AI」を構築している。独自の AI SDR（任意のリクエストに対するリード獲得自動化ソリューション）に特化している。
そして、クライアントを紹介してくれるアフィリエイトを積極的にオンボーディング中で、案件あたり最大 40% を稼げる（我々はすでに巨大デジタル企業 1 社で 40 人の従業員を置き換えた）。
次のレベルまで作り込み、BD チャット・セールスコールの巨大データセットで学習した独自 LLM モデルまで書いた。
市場にまだ誰も持っていないソリューションを扱い販売することに興味があるなら:
このホワイトリストフォームを埋めてほしい: https://forms.gle/Pj4uSHCNzWLKprzUA
Use case 2: AI 駆動のコールドアウトリーチ
これは AI 自動化が本当に輝く領域。汎用コールドメールは死んだ。クライアントは週 1,000+ 件の宛先にパーソナライズされたアウトリーチを期待する。それを可能にするのは自動化だけ。
リソース:
1. Instantly.ai（有料、トライアル有り） https://instantly.ai/
コールドメールの代表的プラットフォーム、フル API あり。
2. Smartlead.ai（有料、トライアル有り） https://smartlead.ai/
類似 API を持つ直接競合。
3. Lemlist API（有料、トライアル有り） https://developer.lemlist.com/
4. Clay の Cold Email Playbooks（無料ブログ） https://www.clay.com/learn
作るワークフロー: Airtable ビューからリードが入ってくる → n8n が直近の LinkedIn 投稿 3 本 + 会社ウェブサイトを取得 → LLM が具体性に言及する、真にパーソナライズされた冒頭文を書く → Instantly / Smartlead が送信 → 返信を AI が分類（interested / not now / not interested / unsubscribe）→ interested は CRM にタスクを自動生成。「Personalized Outreach System — $2,000 初期 + $1,000/月」として販売可能。
Use case 3: CRM オートメーション
どのセールスチームも同じ問題を抱える: 担当者が CRM を更新しない。自動化は人間依存を除去し、全レコードを綺麗に保つ。
リソース:
1. HubSpot API（無料枠） https://developers.hubspot.com/docs/api/overview
2. Pipedrive API（無料枠） https://developers.pipedrive.com/
3. Attio API（無料枠） https://developers.attio.com/
AI ネイティブなスタートアップに好まれる新世代 CRM。
作るワークフロー: 会議が起きるたびに → トランスクリプトを LLM → 主要フィールド抽出（次のステップ、ペインポイント、決裁者、タイムライン）→ HubSpot ディールを自動更新 → 適切な人にフォローアップタスクを割り当て。「CRM Autopilot — $1,500 初期 + $750/月」として販売可能。
Use case 4: コンテンツパイプライン
全ユースケース中で最も利益率が高い。出力は無限で、クライアントは出荷本数で価値を測るから。
リソース:
1. Blotato API（有料、トライアル有り） https://www.blotato.com/
1 回の API 呼び出しで主要プラットフォーム全てに投稿。
2. Buffer API（有料） https://buffer.com/developers/api
3. Notion API（無料） https://developers.notion.com/
多くのコンテンツブリーフが置かれる場所。
作るワークフロー: トピックが Notion DB から入ってくる → AI がプラットフォーム特化の 6 バリアント生成（X、LinkedIn、Instagram、TikTok、newsletter、thread）→ Slack で人間承認を待つ → Buffer で最適時刻に自動スケジュール。「AI Content Engine — $2,500 初期 + $1,000/月」として販売可能。
Use case 5: ミーティングオートメーション
ファウンダーもセールスチームも、会議に何時間も、会議後にも何時間も「書き起こし」作業で費やしている。会議後のプロセス全体を完全自動化できる。
リソース:
1. Fireflies.ai API（有料、トライアル有り） https://docs.fireflies.ai/
2. Otter.ai API（有料） https://otter.ai/api
3. AssemblyAI（無料枠） https://www.assemblyai.com/docs
4. OpenAI Whisper（オープンソース、無料） https://github.com/openai/whisper
作るワークフロー: Zoom 会議終了 → Fireflies トランスクリプトが webhook 経由で到着 → LLM がアクションアイテム、ブロッカー、次回会議日を抽出 → アクションを Linear / Asana に → CRM ディールを自動更新 → 担当者のインボックスに、パーソナライズ済みフォローアップメールのドラフトを送る（レビュー用）。「Meeting Autopilot — $1,200 初期 + $600/月」として販売可能。
Use case 6: 社内ナレッジ bot
どの会社にも、誰も見つけられない膨大な社内ナレッジがある。これは最も価値の高い RAG ユースケースで、売れやすい。
リソース:
1. n8n RAG テンプレート（無料） https://n8n.io/workflows/?q=rag
ドキュメント ingestion と Q&A 向けの事前構築 n8n ワークフロー。ここから始めれば、コードを 1 行も書かずに動くナレッジ bot が作れる。
2. Supabase Vector（無料枠） https://supabase.com/docs/guides/ai
Postgres + pgvector をマネージドベクタ DB として使う。中小クライアント案件に最適。
3. LlamaIndex（デベロッパー路線のみ） https://docs.llamaindex.ai/
完全カスタム RAG パイプラインを作りたい場合。
4. LangChain RAG Tutorial（デベロッパー路線のみ） https://docs.langchain.com/oss/python/langchain/rag
作るワークフロー: ドキュメントを Notion / Google Drive から取得 → チャンク化して埋め込み → Supabase Vector に保存 → Slack 社内 bot が関連チャンクを引用付きで取得して回答。「Internal Knowledge Bot — $2,500 初期 + $500/月」として販売可能。
Month 3 マイルストーン:
今月終わりまでに以下ができる:
- 上記から 1〜2 個の、洗練された再利用可能ワークフローを選び出荷
- それぞれを固定スコープ・固定価格のプロダクト化サービスとして値付け
- Loom で 3 分以内にデモ
- 有料クライアントが 1 人（Early Monetization を実践した場合）、あるいはケーススタディと引き換えの無料パイロットが 1 件
- Month 3 終了までに有料クライアントが 1 人（$300 でも）いたら、もうすでに勝っている。
⏩--------------------------------------------------------------------⏪
Month 4: AI エージェントを道具箱に（慎重に）追加する
今月のゴール: 「AI エージェント」とは実際何かを理解する。いつ使い、いつ使わないかを知る（後者がより重要）。エージェント駆動ワークフローが本当に意味を持つユースケースに限り、サービス提供に加える。
警告: オンラインの「AI エージェント」コンテンツの大半はハイプだ。あなたは地に足をつけたままでいる。70% のケースでエージェントは誤った選択だ。いつが「正しい」選択かを学べば、いまエージェントサービスを売っている人間の 90% より価値がある人になれる。
学ぶこと:
1. エージェントとは本当は何か（何ではないか）
エージェントは魔法ではない。ループだ: LLM が考え、ツールを選び、ツールが走り、結果がプロンプトに戻り、タスクが完了するまで繰り返される。それだけ。
あらゆるエージェントフレームワーク（n8n AI Agent ノード、LangGraph、CrewAI、AutoGen、Lindy、Relevance AI）は、この同じループを別々にラップしているだけだ。
リソース:
1. Anthropic: Building Effective Agents（無料 — 必読） https://www.anthropic.com/research/building-effective-agents
本番でのエージェントに関する最良の文章。何かエージェント関連のものを作る前に読め。交渉不可。
2. OpenAI: A Practical Guide to Building Agents（無料 PDF） https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
エージェントパターン、ガードレール、安全性をカバー。
フォーカス:
- perceive → plan → act → observe ループ
- ループがどう終わるか（モデルが「終わった」と言う、または最大反復上限に達する）
- エージェントは要するに「LLM が分岐判断をする while ループ」にすぎない、という事実
- 各フレームワークが実際には何を抽象化しているだけなのか
2. 最初のエージェントを作る（n8n の中で）
ノンテク路線ではここだ。n8n の AI Agent ノードが、ループ・ツール呼び出し・状態管理を代行してくれる。ノードをドラッグし、ゴールを与え、「ツール」サブワークフローを接続し、動かす。
リソース:
1. n8n AI Agent Node Docs（公式、無料） https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
n8n のエージェントノードの完全リファレンス。全部読め。
2. n8n AI Agent テンプレート（無料） https://n8n.io/workflows/?categories=AI
テンプレートを 3 個インポート、実行、配線をリバースエンジニアリング。チュートリアル 100 本より価値がある。
フォーカス:
- system プロンプトでエージェントのゴールを明確に定義する
- 正しいツールだけを露出する（最初は 3〜5 個に絞る）
- 誤解不可能なツール説明を書く
- 最大反復上限を設定する（通常 10〜15）。エージェントが永遠に回らないように。
- 不可逆なアクションには必ず human-in-the-loop 承認ステップを入れる
練習プロジェクト: n8n 内に Tier 1 カスタマーサポート案件を処理するサポートエージェントを構築する。要件:
- チケットを分類する（billing / technical / account / feature request）
- 既知の問題はナレッジベース（Notion / Google Drive）から修正方法を参照して返信
- アカウント関連はツール呼び出しで情報取得
- それ以外は、コンテキスト要約付きで Slack にエスカレーション
- 信頼度チェックなしの返信は絶対に送らない
3. エージェント vs シンプルチェーンの使い分け
今月学ぶなかで最も価値があるのは、「いつエージェントを使わないか」。
判断フレームワーク:
- 単一 LLM コール: 十分なコンテキストを与えて 1 プロンプトで解けるタスク
- 固定チェーン: ステップが予測可能で常に同じ順で走る（多くのワークフロー！）
- エージェント: ステップ数が真に未知で、入力に依存する場合のみ
リソース:
1. Anthropic: "When to use agents"（無料） https://www.anthropic.com/research/building-effective-agents
2. Simon Willison: Designing Agentic Loops（無料） https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
暗記せよ: 3 つの LLM コールからなる固定チェーンは、3 回コールするエージェントよりも常に速く、安く、デバッグしやすい。エージェントは真にオープンエンドなタスク（リサーチ、多段カスタマーサポート、柔軟なセールスアウトリーチ等）にだけ使う。
4. Human-in-the-loop（人間チェックポイント）
本格的なビジネス自動化の多くは、どこかに人間承認ステップが要る。特にエージェントが不可逆的行動をしようとしているとき（メール送信、公開投稿、ディールステージ更新、カード課金）。
リソース:
1. n8n: Wait Node（無料） https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/
Webhook や時間トリガーが来るまでワークフローを一時停止する n8n の組み込み手段。承認ゲートに使う。
2. Slack Block Kit Builder（無料） https://api.slack.com/block-kit
Slack メッセージ内のインタラクティブ承認ボタンの作り方。
フォーカス:
- 必ず人間承認が必要なアクションの識別（send, publish, pay, update）
- Slack、メール、軽量フォームでの承認 UI 構築
- approve / reject / edit の応答を、状態を壊さずに処理する
- 人間が応答しないときのタイムアウト
5. エージェントを信頼できるものにする（デモでは見えない部分）
デモのエージェントは動く。本番のエージェントは本物の信頼性エンジニアリングが必要だ。
フォーカス:
- 最大反復上限 — エージェントが永遠ループに陥らないように
- ツールごとのリトライとフォールバック
- ツール呼び出しを全てログ、後から何が起きたかをデバッグ可能に
- エージェントが混乱したときの人間エスカレーション経路を追加
6.（デベロッパー路線のみ）Python エージェントフレームワーク
ノンテクはスキップ。
デベロッパー路線なら、より高単価なカスタムエージェント案件を解放できる:
1. LangGraph（無料コース） https://academy.langchain.com/courses/intro-to-langgraph
最も広く使われるエージェントオーケストレーションフレームワーク。
2. CrewAI（無料、OSS） https://docs.crewai.com/
ロールベース協調のマルチエージェントフレームワーク。
3. AutoGen（Microsoft、無料、OSS） https://microsoft.github.io/autogen/
Month 4 マイルストーン:
- 3〜5 個のツールを安定して使う、n8n 内の動作する AI エージェントを作れる
- あるタスクが「単一コール」「固定チェーン」「エージェント」のどれで解くべきかを自信を持って判断できる
- さまざまな入力に対して正しく選択される、ツール説明を書ける
- 不可逆なアクションを取るワークフローには、Human-in-the-loop 承認を追加できる
- クライアントに対して「ここでエージェントはオーバーキルです」と言い、よりシンプルな解を提示できる
⏩--------------------------------------------------------------------⏪
Month 5: 自動化を本番対応にする
今月のゴール: Month 1〜4 で作ったもの全てを、本物のクライアント、本物のトラフィック、本物の午前 2 時の障害に耐えるものにする。
Month 5 末までに、自動化をデプロイ・監視し、ノンテクなクライアントに引き渡せる（稼働率と応答時間も自信を持って約束できる）ようになる。
学ぶこと:
1. デプロイ（まず Railway のワンクリック n8n を使う）
良いニュース: 今月は Docker や DevOps を学ぶ必要はない。Railway にはワンクリックで n8n をデプロイできる機能がある。ボタンを押してカスタムドメインを追加すれば、5 分で本番 n8n インスタンスが出来る。
それをやれ。考えすぎるな。Docker、リバースプロキシ、Kubernetes は「後で」学ぶ（クライアントが 5 人を超え、実際に必要になったときに）。
リソース:
1. Railway（無料枠、推奨） https://railway.app/
n8n のセルフホストに最速の方法。テンプレートで「n8n」を検索してデプロイ。
2. Render（無料枠） https://render.com/docs/deploy-n8n
もう 1 つの優れたワンクリックオプション。
3. n8n Cloud（ホスト型、有料） https://n8n.io/cloud/
クライアントがインフラを一切持ちたくない場合のゼロ手間オプション。費用は高いが運用ゼロ。
フォーカス:
- Railway 上でカスタムドメインと HTTPS 付きで n8n をデプロイ
- シークレットは環境変数（キーをキャンバスに直接貼らない）
- 自動バックアップの設定
- 落ちた時にまず何をするか（ステップ 1: Railway ステータスページを見る）
（デベロッパー路線は後で）: Docker Compose、マネージド Postgres、Caddy リバースプロキシで n8n をセルフホスト。クライアントが 3〜5 人になるまでスキップでよい。
2. ロギングと監視（クライアントが気づく前に壊れを知る）
自動化の中で何が起きているか見えなければ、壊れたものを直せない。そして、午前 0 時にクライアントからメールが来るまで障害に気づけない。
リソース:
1. n8n ビルトインの実行ログ（無料） https://docs.n8n.io/workflows/executions/
n8n のビルトインロギングは実はほとんどのユースケースで非常に良い。まずこれをマスター。
2. Better Stack（無料枠） https://betterstack.com/
稼働率監視。n8n インスタンスが落ちたらページに飛ばしてくれる。
3. Langfuse（無料枠） https://langfuse.com/
LLM 特化のオブザーバビリティ。プロンプト、レスポンス、トークン数、レイテンシを全部トレース。Month 5 ではオーバーキルだが、存在を知っておくと良い。
フォーカス:
- デプロイ後の数週間は毎日 n8n 実行ログをチェック
- Better Stack に n8n URL を 1 分ごとに ping させ、落ちたらアラート
- クリティカルなワークフローが失敗したら Slack / Telegram で自分に通知
- クライアントから障害を初めて知るのは絶対に禁止
3. プロンプトのバージョニング（本番ワークフローのプロンプトをランダムに変えない）
あなたのプロンプトはコードだ。バージョン管理が必要だ。ライブワークフローのプロンプトをランダムに変えることは、サイレントに物を壊す最短経路。
リソース:
1. 退屈だが安全なやり方（初心者におすすめ）:
すべてのプロンプトを Notion DB / Google Doc に格納し、バージョンごとに日付ラベル、どれが本番かを常に明確にする。
2. Langfuse Prompt Management（無料枠） https://langfuse.com/docs/prompts
中央集権型のプロンプトストレージ、バージョニングと組み込みプレイグラウンド。
フォーカス:
- クライアントのライブワークフローのプロンプトを、テストなしに編集しない
- 各プロンプトの直近 3 バージョンを保持してロールバック可能に
- プロンプトを変えるたびに「なぜ変えたか」を書き残す
4. セキュリティの基本
クライアントを失う最速の方法は、API キーを晒したり、他人に彼らのデータを触らせたりすることだ。
リソース:
1. OWASP Top 10 for LLM Apps（無料） https://genai.owasp.org/llm-top-10/
プロンプトインジェクションを含む LLM 特有のセキュリティリスク。1 時間で読める。
2. n8n Credentials Docs（無料） https://docs.n8n.io/credentials/
n8n の API キーの安全な保管方法。ノードパラメータにキーを直貼りするな（常に credentials システムを使う）。
フォーカス:
- API キーを GitHub や公開ドキュメントにコミットしない
- 全 API キーを n8n の組み込み credentials vault に入れる
- ワークフローからキーが漏洩したらローテート
- LLM にユーザー入力を渡す前にサニタイズ（プロンプトインジェクション防御）
- LLM 出力を、人間レビューなしに不可逆アクションに使わない
5. ドキュメントとクライアントハンドオフ（レートを 5 倍にする秘訣）
$500 プロジェクトと $5,000 プロジェクトの差は、しばしばドキュメントだけだ。美しくドキュメント化されたワークフローと Loom で引き渡せば、クライアントは大切にされている感覚を持つ。ラベルなしの n8n キャンバスを渡せば、迷子になる。
リソース:
1. Loom（無料枠） https://www.loom.com/
全ワークフローに 3〜5 分のウォークスルー動画を録る。クライアントは大好きだ。
2. n8n Sticky Notes（無料） https://docs.n8n.io/workflows/sticky-notes/
ワークフロー内で各セクションが何をするかの説明に多用する。
3. クライアントハンドオフ用 Notion テンプレート（無料） https://www.notion.so/templates
「client handoff」で検索して恥じずにパクれ。
フォーカス:
- 自動化ごとに 1 ページの概要ドキュメント: 何をするか、何でトリガーされるか、何を更新するか、壊れたときの対応
- 非自明なワークフローには 3〜5 分の Loom
- n8n キャンバスに sticky note で「なぜこうなっているか」を書く
- 最も起こりやすい 5 つの失敗モードと対応を書いた簡易 runbook
- 監視ダッシュボードのチェック方法をクライアントに教える
6. ベーシック SLA
リテナー契約を始めると、クライアントは「何を約束してくれる？ 外したらどうなる？」と聞いてくる。エンタープライズ契約は不要だ。必要なのは明確さ。
フォーカス:
- 稼働率コミットメント（自動化業務なら 99% が妥当）
- 問題発生時の応答時間（X 時間以内に返信、Y 以内に修正）
- スコープ境界（何が含まれる、何が追加費用）
- 緊急障害時のエスカレーション経路
Month 5 マイルストーン:
- 自分のワークフローを 10 分以内に Railway にデプロイできる
- クライアントが気づく前に障害を知らせる監視を設定できる
- ワークフロー・Loom・runbook・監視ダッシュボードを綺麗にパッケージしてハンドオフできる
- リテナー契約の基本 SLA を書いて交渉できる
- 自分のワークフローが監視されていると知り、安心して寝られる
⏩--------------------------------------------------------------------⏪
Month 6: 方向を選び、スケールする
ここまでで、あなたは「実際に動くワークフロー 1〜2 個、有料クライアント最低 1 人（望むらくはそれ以上）、デプロイ済み本番セットアップ、ポートフォリオの萌芽」を持っている。Month 6 は、どの方向にスケールするかを選ぶ月だ。
本物の 3 つの道。ひとつだけ選び、全力投球する。
Direction 1: フリーランス・オートメーションビルダー
クライアントを素早く獲得し、30〜60 日で収入が欲しい人に最適。
本物の収入への最速経路。中小企業、エージェンシー、コーチ、SaaS ファウンダーにワークフロー構築とリテナーを直販。低オーバーヘッド、高マージン、数週間で現金化。
フォーカス:
- 再利用可能なワークフローテンプレート 2〜3 個（リードジェン、コールドアウトリーチ、コンテンツパイプライン、サポート bot）
- 実数値のあるケーススタディを各 1 本
- SMB / エージェンシー / コーチ / SaaS ファウンダー向けのコールドアウトリーチ
- 価格: 最初は $500〜$2k / プロジェクト、レビューが溜まったら $1〜3k/月のリテナーへ
今月学ぶこと:
1. サービスのプロダクト化
時間を売るな。アウトカムを売れ。「Lead Gen Pipeline セットアップ — $1,500」は「カスタム自動化、時給制」より 10 倍コンバートする。
リソース:
1. Productized Services Guide（Pieter Levels、無料） https://nomadlist.com/forum/post/3471
2. Sahil Lavingia のブログ（無料） https://sahillavingia.com/
フォーカス:
- 2〜3 個のサービスを選び、固定スコープと固定価格を書く
- それらのサービスだけを示すポートフォリオサイト（Notion ページか Carrd で十分）
- プロダクト化していないカスタム案件に Yes と言わない
2. コールドアウトリーチとクライアント獲得
売ることから逃げられない。朗報: Month 3 で自分のアウトリーチに使うそのツール自体をあなたはすでに作っている。
リソース:
1. Instantly Blog（無料） https://instantly.ai/blog
2. Nick Saraev（YouTube、無料） https://www.youtube.com/@nicksaraev
自動化エージェンシー向けのアウトリーチとセールスに特化。
フォーカス:
- ターゲットニッチの企業 500〜1,000 社のリード一覧構築
- 明確な ROI 主張と一緒に、1 つの具体的自動化を提案するパーソナル化されたコールドメールを書く
- 週 3〜5 件の discovery call を入れる
- 「先に作り、後で払う」パイロット案件でファーストケーススタディを取る
3. ケーススタディとソーシャルプルーフ
よくドキュメント化されたケーススタディ 1 本は、アウトリーチメール 500 通よりも多くのクライアントを連れてくる。最初のプロジェクトを出荷した瞬間に最初のケーススタディを作れ。
フォーカス:
- Before/After の指標（時間削減、売上創出、コスト削減）
- 明確な物語: 問題 → 作ったもの → 結果
- 視覚的証拠としてのワークフロー Loom
- クライアントの証言コメント
Direction 2: イン・ハウス・オートメーションビルダー
安定と給与が欲しい人向け。
1 社の社内でフルタイムロールに就き、社内自動化システムを作って会社の時間とお金を節約する人向け。
フォーカス:
- オペレーション・社内ツール系ユースケース
- AI を既存社内スタック（Slack、Notion、HubSpot、Salesforce）に接続
- 社内エージェントとダッシュボードの構築
- 時間・コスト削減の厳格な計測
今月学ぶこと:
1. 社内ツール構築
リソース:
1. Retool（無料枠） https://retool.com/
社内ツールを高速に作る業界標準。
2. Streamlit（OSS、無料） https://streamlit.io/
Python 駆動の社内ツールを最速で作る方法。
3. Budibase（OSS、無料） https://budibase.com/
Retool の OSS 代替。
フォーカス:
- 会社内の最高価値な自動化対象の特定
- ノンテク社員が実際に使えるシンプル UI
- ステークホルダーからのサインオフとリソース割り当て獲得
2. ROI を正しく計測する
イン・ハウスのビルダーは、計測可能なビジネスインパクトで昇進する。X 時間 / $Y を節約した証明ができなければ、存在感ゼロだ。
フォーカス:
- 出荷した全自動化の before/after 指標を追跡
- 月次 wins ドキュメントに数字を提示
- 直接影響（時間削減）と間接影響（エラー減、満足度向上）の両方を計算
- 次の評価・転職活動で再利用できるステークホルダーの証言を確保
3. キャリアポジショニング
フォーカス:
- 社内ドキュメントやブログに自動化の成果を書く
- 社内ミーティング、デモデイ、all-hands でプレゼン
- サニタイズ版ケーススタディを LinkedIn / X で共有
- 各評価で見せる「作ったプロジェクト」ドキュメントを維持
Direction 3: AI 自動化エージェンシー
時間切り売り以上にスケールしたい人向け。
最も天井が高いが、最も難しい道。チーム、再現可能なサービス、本物の事業を作る（フリーランス収入ではない）。
フォーカス:
- 明確な納品物を持つ再現可能サービスの構築
- 雇用 / パートナーでの履行
- 業界で絞る（不動産、EC、リクルーティング、リーガル）
- ワークフローをテンプレート化して販売 / ライセンス
今月学ぶこと:
1. 再現可能サービスを作る
エージェンシーが成立するのは「同じサービスを複数人が同じ方法で提供できる」ときだけ。これがエージェンシーとフリーランサーを分ける。
リソース:
1. The E-Myth Revisited（書籍） https://www.amazon.com/E-Myth-Revisited-Small-Businesses-About/dp/0887307280
サービス事業を仕組み化する古典。人を雇う前の必読書。
2. Built to Sell（書籍） https://www.amazon.com/Built-Sell-Creating-Business-Without/dp/1591845823
エージェンシーを「あなた不在でも回る事業」にする方法。
フォーカス:
- 納品プロセスの各ステップを SOP としてドキュメント化
- 納品物とタイムラインを明示
- プロダクト化された価格: 「Lead Gen Package — $3,500 初期 + $750/月」
2. ニッチに絞る
ジェネラリスト・エージェンシーは死ぬ。ニッチ・エージェンシーは栄える。業界を 1 つ選んで所有する。
フォーカス:
- 3〜5 業界をリサーチし、文脈がある・価格帯が高い・問題が普遍的、の 1 つを選ぶ
- ニッチ特化のテンプレートとケーススタディを作る
- ポートフォリオとアウトリーチをそのニッチに合わせて書き直す
3. 雇用と委譲
リソース:
1. OnlineJobs.ph（有料、国際） https://www.onlinejobs.ph/
2. Upwork（無料、グローバル） https://www.upwork.com/
フォーカス:
- まずオペレーターを雇う（既存ワークフローを回せて、クライアントと話せる人）
- 雇う前にタスクレベルの SOP を書く
- 最初の雇用はパートタイム（仕事量が本当にあると確信するまで）
- 有料クライアント 3 人未満のうちは雇わない
Direction 3 の練習プロジェクト:
業界を 1 つ選ぶ（例: 不動産）。その業界の 3 大反復問題（リード選別、物件説明文生成、予約リマインダ）を解くワークフローを 3 個作る。「Real Estate AI Automation Suite」として、固定価格と明確な納品物リスト付きでパッケージ。初日から市場に持ち込める販売可能プロダクト。
⏩--------------------------------------------------------------------⏪
結論
6 ヶ月後に何が期待できるか？
正直に言う、「金の山」を盛って語らずに。
このロードマップは、6 ヶ月であなたを次代の Zapier CEO にはしない。
だが、実在のビジネス問題を解く、本物の AI 自動化を構築・出荷・デプロイできる人間にはする。
そして現在、まさにそれこそが市場が金を払っている対象だ。
AI 自動化の需要は減速していない。LinkedIn の 2026 Jobs on the Rise レポートは、「AI automation specialist」を最も急成長する職種の Top 5 に挙げている。
McKinsey は、多くのオフィス職で従業員時間の 60〜70% が、現行の AI + ワークフローツールで自動化可能と試算している。
SMB のうち意味のある AI 自動化を導入済みは約 2% にすぎない、つまり市場の 98% はまだ完全に未着手。
これはハイプ数字ではない。実データに基づいた本物の数字だ（Claude から取ってきた笑）。
US / EU でフルタイムに行く場合:
1: ジュニア AI Automation Builder: $75,000〜$110,000
2: ミッドレベル（2〜4 年）: $125,000〜$180,000
3: シニア・ビルダー / オートメーションアーキテクト: $180,000〜$280,000+
ミッドレベルが最速で伸びている。企業は、監督なしで安定した本番自動化を出荷できる人間を切実に求めている。
フリーランスのほうが向くなら:
4: AI ワークフロー構築: 1 プロジェクトあたり $500〜$5,000
5: 月次リテナー: 基本メンテは $500〜$2,000/月、アクティブ開発付きは $3,000〜$8,000/月
6: スペシャリスト時給: ニッチにより $100〜$250/時間
私自身、SMB 向けに n8n ワークフローだけを一人で作って月 $15,000 稼いでいるフリーランサーを個人的に知っている。仕事は存在していて、市場はいまだに深刻に供給不足だ。
コンサル / エージェンシー路線なら:
7: 1 社向け AI 自動化セットアップ: $500〜$5,000
8: マネージド自動化サービス: $1,000〜$5,000/月
9: フルカスタムエージェントシステム構築: $3,000〜$15,000
10: エンタープライズグレードの自動化パッケージ: $10,000〜$50,000
天井は実質ない。2 人のオートメーションエージェンシーが 15〜20 クライアントを抱えて $80k/月の経常収益を上げているのを見ている。
これは、2026 年現在、実在の人が実在の仕事で叩き出している実数字だ。
さて、あなたに本当に持って帰ってほしいのはこれだ:
各月から 1 つワークフローを選んで作れ。読むな。チュートリアルを見るな。作れ。壊せ。直せ。デプロイしろ。GitHub かポートフォリオサイトに置け。雇われるビルダーは、勉強したことではなく、作ったものを見せた人間だ。
学んだことをシェアし始めろ。X、LinkedIn、どこでもいい、書け。教えることは最速の学習であり、同時に評判を積み上げる方法でもある。私が見てきた最良のクライアントは、可視化されている人のところに来る。500 件の求人に応募した人のところではない。
そして、準備ができたと感じるまで待たないでほしい。準備ができたと感じる瞬間は永遠に来ない。「学んでいる」と「作っている」の間のギャップこそ、多くの人が永遠に詰まる場所だ。
動く自動化が 1 個できた瞬間から、応募を始め、フリーランスを始め、サービスを提供し始めろ。荒くていい。市場は完璧に報酬を払わない。出荷できる人に報酬を払う。
本気でやれば、6 ヶ月ですべてを変えられる。
これを読んでいる全員がそれをやれると、私は本気で信じている。
ただし、構築を止めるな。学習を止めるな。
これが役に立ったなら嬉しい、fam ❤️
タイトル: How to become an AI Automation Builder in 6 months (RESOURCES)
AI automation has quietly become the highest-ROI skill in the entire AI space right now
The problem is that most people entering this field get stuck the same way
Some open a Python tutorial on day one, hit a wall in week two, and never touch a no-code tool
Some get lost in 8-hour YouTube tutorials without ever building a single workflow for a real business
Others jump straight into "AI agents" without understanding how a basic workflow or an API actually works
The result is always the same: a folder of half-finished demos and zero paying clients
Here's the truth almost nobody tells beginners:
"You don't need to become a software developer to become an AI Automation Builder!!!"
"You don't need to learn machine learning"
"You don't need to fine-tune a model"
You need to learn how to connect AI to the tools companies ALREADY use and automate the boring, repetitive work they are currently paying humans to do
That means learning how to:
build end-to-end automated workflows across real business tools
wire AI into CRMs, email, docs, and support systems
turn repetitive human tasks into reliable AI-powered pipelines
ship automations that survive real client traffic
charge $500-5k/mo and deliver measurable ROI
This guide was created to give you a practical 6-month roadmap
The article is 10,000+ WORDS, so reading it may take a few hours
But its real value is that for every skill you need to learn, there are resources and clear explanations of what to do next
That way, within six months you can reach the level of a hireable AI Automation Builder, and start earning from it already within the first 1-2 months
[ Now let's start reading the article ] ⬇️
Read this first: non-technical path vs developer path
This roadmap works for two different kinds of people, and you need to pick which one you are BEFORE you start
Non-technical path (DEFAULT — most of you are here)
You have never coded, or you know a little but you don't want to become a developer. Your superpower is going to be no-code tools (n8n specifically), connected to AI through simple nodes. You can build and sell real automations without ever writing a line of Python if you don't want to. This is the fastest, most realistic path to your first paying client
Developer path (OPTIONAL add-on)
You already code, or you really want to learn. You will follow the same roadmap but ALSO pick up Python, LangGraph, and custom backend pieces. This unlocks bigger contracts and more complex work later, but it is completely optional
Every month below is written for the non-technical path first. At the end of each section, there's an optional "developer path" box with the extra stuff to learn if you want to go that direction. Skip it without guilt if you don't
One rule: pick a lane and stop switching. People who bounce between "I'll learn no-code" and "I'll learn Python" for 6 months end up with neither
What an AI Automation Builder actually does?
A lot of people hear "AI automation" and imagine shiny AI agents that replace entire teams
In reality, most of the work is much more boring and much more profitable
You take expensive, repetitive business processes and rebuild them as AI-powered workflows that run 24/7 without humans babysitting them
That usually includes:
connecting LLMs to tools companies already use (CRMs, email, Slack, Notion, databases)
turning triggers from one system into actions in another
adding AI decision-making into previously manual workflows
replacing human triage, classification, and routing work with LLM calls
building internal knowledge bots over company docs
automating lead generation, outreach, content, and support pipelines
monitoring and handing these systems off to non-technical clients
So in practice, an AI Automation Builder sits somewhere between:
workflow automation (n8n, Make, Zapier)
applied AI (LLMs, prompts, simple agents)
business process consulting (knowing what's actually worth automating)
light technical glue work (reading docs, fixing small things, debugging)
This is why the role is exploding right now
Every SMB, agency, and SaaS company in 2026 has 20 repetitive workflows they are paying humans too much to run
They don't need researchers. They don't need fine-tuners. They need someone who can walk in, find the bleeding, and stop it with a workflow that pays for itself in the first month
That's also why this roadmap focuses less on building products and more on shipping business outcomes
If you can wire AI into a real CRM, a real inbox, and a real content pipeline, you're already more employable than 90% of people calling themselves "AI engineers" on LinkedIn
Also, until we started, let me give to you a little motivation to learn it:
Still 310M companies which haven't applied and added any kind of automation!!!
Into the world, here's in general 360M (only 50M companies added partial automation to their business processes)
And THE MOST IMPORTANT THING, in total ONLY 1M people into the world might provide this service on decent level
Lol, 8B+ ppl live on this planet, THAT'S ABSOLUTELY NOTHING. WE'RE SO EARLY!!!
Also, catch potential rates which you can appoint to any of these automations:
- $500-5k/mo to build automated workflows for businesses
- $1-3k/mo to automate lead generation systems
- $500-2k/mo for AI-powered content pipelines
- $1-4k/mo to automate customer support with AI agents
- $500-2k/mo for automated reporting & data dashboards
- $500-2k/mo for AI-powered cold outreach systems
- $1-3k/mo to set up internal automation assistants
- $500-1.5k for AI workflow training for teams
- $300-1k for 1:1 automation consulting
*It's average prices which I could find across different freelance and outsource platforms + my frens who are doing it professionally shared with me
That means they can be much higher (depends on the company size and how many employees they would love to fire lol)
LET'S BEGIN!!!
⏩--------------------------------------------------------------------⏪
Month 1: Build your first workflow in n8n
Your goal this month: Build your first real automation in n8n, understand how APIs and webhooks work at a conceptual level, and learn enough about prompting to make an LLM do what you want
You are NOT learning Python this month (unless you're on the developer path). You're learning the one tool that is going to pay your bills for the next 6 months, and the vocabulary you need to read docs without panicking
What to learn:
1. Pick ONE no-code platform and go deep (start HERE)
This is the most important decision of Month 1. Pick ONE tool. Go deep. You can learn the others later in a weekend once you understand the underlying concepts
Which one to pick:
n8n: pick this if you're serious about this career. Open-source, generous free tier, best-in-class AI nodes, self-hostable, and the automation agencies making real money are all here. This is the default recommendation for this entire roadmap
Make (formerly Integromat): pick this if you want the prettiest visual interface. Great for agency client work and complex branching
Zapier: pick this ONLY if you're building quick MVPs for non-technical clients who already use it. Too expensive at scale for serious work
My recommendation: go with n8n. Everything in this article assumes n8n unless stated otherwise
Resources:
1. n8n Official Docs (free)
Link: https://docs.n8n.io/
Start with "Quickstart" and work through every core concept. The docs are genuinely excellent
2. n8n Academy (free)
Link: https://docs.n8n.io/courses/
Official free courses covering beginner to advanced workflow patterns, including AI integration. This is the single best resource in the entire 1st month
3. Productive Dude (YouTube, free)
Link: https://www.youtube.com/@productivedude
n8n-focused, extremely practical, beginner-friendly videos
4. Nick Saraev (YouTube, free)
Link: https://www.youtube.com/@nicksaraev
Focused specifically on making money with automation. High signal
5. Make Academy (free, if you picked Make)
Link: https://academy.make.com/
What to focus on:
Triggers (cron, webhook, app events) vs actions
How data moves from one step to the next
Error handling and fallback paths
Using the HTTP Request node when there's no native integration
Reading and debugging execution logs
The built-in OpenAI and AI Agent nodes (you'll use these in Month 2)
Practice: Automate something in your own life. Seriously. Auto-save email attachments to Google Drive. Scrape a product price daily into a Google Sheet. Send yourself a Telegram message when a specific keyword appears in your inbox. Build the muscle with low stakes before you build for clients
2. APIs, webhooks, and JSON (the vocabulary, not the code)
Every automation you ever build connects two systems through APIs. You don't need to CODE APIs. You need to UNDERSTAND them enough to read a doc, know what a webhook is, and know what JSON looks like when you stare at it
Resources:
1. What is a Webhook? (Zapier blog, free)
Link: https://zapier.com/blog/what-are-webhooks/
The best beginner explanation of webhooks, written for non-developers
2. HTTP basics — MDN Web Docs (free)
Link: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
Clearest free explanation of how the web talks to itself
3. Postman Learning Center (free)
Link: https://learning.postman.com/
Postman is the universal tool for testing APIs. Go through "Getting Started" before touching any real API. You click buttons. No code
4. REST API Tutorial (free)
Link: https://restfulapi.net/
Short, practical, no unnecessary theory
What to focus on:
GET vs POST vs PUT vs DELETE (what each is used for)
What JSON looks like (curly braces, key-value pairs, arrays)
HTTP status codes: 200 (good), 401 (bad auth), 404 (not found), 429 (rate limited), 500 (broken)
API keys and bearer tokens at a conceptual level (you paste them, you don't build them)
Webhooks vs polling (when to use each)
Rate limits and what happens when you hit them
Practice: Use Postman to call a free public API (try https://api.github.com/users/torvalds). See the JSON come back. Now recreate the exact same call inside an n8n HTTP Request node. Compare. This one exercise unlocks 50% of the mystery of APIs for non-technical people
3. Reading API docs without panicking
Every real automation eventually requires reading an API doc. This is the skill that separates people who ship from people who wait forever for a YouTube tutorial that covers their exact use case (spoiler: it doesn't exist)
Resources:
1. How to Read API Documentation — Postman Blog (free)
Link: https://blog.postman.com/how-to-read-api-documentation/
Short, practical breakdown of how API docs are structured
2. Stripe API Docs (free, best-in-class example)
Link: https://docs.stripe.com/api
Study this even if you never use Stripe. It's the gold standard for API documentation design
What to focus on:
Finding the "Authentication" section first, always
Identifying the base URL, endpoint paths, methods, required parameters
Reading request/response examples
Spotting rate limits and pagination patterns
Testing one endpoint in Postman before wiring it into a workflow
Practice: Pick any tool you already use (Notion, Airtable, Slack, HubSpot) and make ONE successful API call from Postman. Just one. Pull a list of something. Then stop
4. Basic prompt engineering
You don't need to become a prompt wizard. You need to understand the fundamentals: system vs user prompts, specificity, examples, and how to force structured output so the rest of your workflow can use it
Resources:
1. Anthropic's Interactive Prompt Engineering Tutorial (free, GitHub)
Link: https://github.com/anthropics/prompt-eng-interactive-tutorial
The best hands-on intro to prompting, broken into chapters with exercises
2. OpenAI Prompt Engineering Guide (free)
Link: https://platform.openai.com/docs/guides/prompt-engineering
3. Learn Prompting (free, comprehensive)
Link: https://learnprompting.org/
A full free course from basics to advanced
4. Advanced Prompt Engineering Article from @EXM7777 (free)
Link: https://x.com/EXM7777/status/2011800604709175808
What to focus on:
System prompts vs user prompts
Why specificity beats cleverness
Giving examples (few-shot prompting)
Asking for structured output (JSON, CSV, specific formats), this is what makes AI usable inside automations
Chain-of-thought for tasks that require reasoning
5. What LLMs are actually good at (and where they fail)
This one saves you from embarrassing yourself in front of a client. Knowing when NOT to use AI is just as valuable as knowing when to use it
Resources:
1. Andrej Karpathy YouTube talks (free)
Link: https://www.youtube.com/@AndrejKarpathy
Clearest thinking on where LLMs add real value
2. Simon Willison's Blog (free)
Link: https://simonwillison.net/
The most practical voice in applied AI. Read his recent posts
What to memorize:
Good at: classification, summarization, extraction, translation, drafting, decision trees with clear criteria
Bad at: exact math, real-time data without retrieval, tasks requiring perfect consistency, anything safety-critical
6. (Developer path only) Just enough Python to unblock yourself
Skip this section if you're on the non-technical path
If you want the dev path, learn just enough Python to read docs, write small scripts, and glue things together when a no-code tool hits a wall. Not to become a senior dev
Resources:
1. Python for Everybody (Coursera, free to audit)
Link: https://www.coursera.org/specializations/python
2. freeCodeCamp Python Course (YouTube, free)
Link: https://www.youtube.com/watch?v=rfscVS0vtbw
3. Automate the Boring Stuff with Python (free online book)
Link: https://automatetheboringstuff.com/
Specifically for people who want to automate tasks, not build apps
What to focus on: variables, loops, conditionals, functions, lists, dicts, JSON, reading files, requests library, try/except, running scripts from terminal
Month 1 Milestone:
By the end of this month you should be able to:
Build a 3-5 step workflow in n8n that solves a real problem in YOUR own life
Explain what webhooks, API keys, JSON, and HTTP status codes are (in plain English)
Read an unfamiliar API doc and successfully make a test call with Postman
Write a clear system prompt that returns consistent structured output
List 5 tasks LLMs are good at and 5 where they'll embarrass you
If you hit all of these, you're already ahead of 80% of people trying to "break into AI" right now
⏩--------------------------------------------------------------------⏪
Month 2: Embed AI into your workflows
Your goal this month: Stop using ChatGPT manually. Start making AI run automatically inside your n8n workflows, reacting to real triggers, making decisions, and writing to real systems (without you pressing a button)
By the end of Month 2 you should have 3-5 real workflows that use AI inside them, and you should already have a clear idea of what your FIRST paid gig will look like
This is the month where you stop being a no-code user and start being an AI Automation Builder
What to learn:
1. n8n's AI nodes (the default path)
n8n has built-in nodes for OpenAI, Anthropic, and a full AI Agent node. For 90% of what you'll ever need to ship, you don't need to touch Python at all. You drop an AI node into your workflow like any other step
Resources:
1. n8n AI Nodes & LangChain Docs (official, free)
Link: https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
Walk through the full AI section of their docs. The n8n team has done an insane amount of work making AI usable from a no-code canvas
2. n8n Academy: AI Workflows Course (free)
Link: https://docs.n8n.io/courses/
There's a dedicated AI track. Do it
3. n8n AI Templates (free)
Link: https://n8n.io/workflows/?categories=AI
100+ real, importable templates. Better than any tutorial (import one, run it, see exactly how it's wired)
What to focus on:
Dropping an OpenAI or Anthropic node into a workflow
Passing data FROM a previous step INTO the prompt dynamically (expressions in n8n)
Parsing the AI response and using specific fields in later steps
Keeping your prompts in a central place (a Notion doc or a dedicated n8n sub-workflow) so you can edit them without digging
When to use AI inline vs when a simple IF node is enough
Practice project: Build a workflow that watches a Google Form, sends new responses to an LLM for classification (urgent / normal / spam), and writes the classified response into different Airtable tables based on the category. No code. Pure n8n
2. The core skeleton: Trigger → AI Decision → Action → Output
Almost every AI automation you will ever build fits this skeleton:
Trigger (something happens) → AI decision (classify, extract, generate) → Action (write to a system) → Output (notify / log / confirm)
Master this one skeleton and you can already build 80% of real-world automations without ever touching an "agent"
Resources:
1. Anthropic: Building Effective Agents (free)
Link: https://www.anthropic.com/research/building-effective-agents
Read the "Workflow patterns" section. Covers prompt chaining, routing, and parallelization with clear diagrams. Ignore the agent-framework stuff for now
2. n8n AI Templates (free)
Link: https://n8n.io/workflows/?categories=AI
Pick 3 templates that match this skeleton and dissect them
What to focus on:
Sketching the workflow on paper BEFORE you drag a single node
One LLM call per decision (don't try to make one giant prompt that does everything)
Idempotency (running the same workflow twice shouldn't double-process)
Where to use an IF node (deterministic) vs an AI node (fuzzy)
Practice project: Build a workflow that reads incoming emails (Gmail trigger), uses AI to classify into {support, sales, personal, spam}, and routes each category to a different action. Create a ticket, create a CRM lead, forward, or archive. No agents. Just a clean chain
3. Error handling and fallback logic (the "clients will actually pay you" part)
Your workflows will fail in production. APIs go down. Rate limits get hit. The LLM returns malformed JSON. Clients don't pay you to build things that work 90% of the time. They pay you for things that work 99.9% and gracefully handle the other 0.1%
Resources:
1. n8n: Error Handling & Error Workflows (free)
Link: https://docs.n8n.io/flow-logic/error-handling/
How to build a global error handler that catches any failure in any workflow. This is n8n's single best feature for production
2. n8n: Retry on Fail (free, same page)
Built into every node. Learn it early
3. Nate Herk: Workflow for Unlimited Error Handling (free)
Link: https://www.youtube.com/watch?v=bTF3tACqPRU
He has literally explained 95% of potential errors and failures which might appear
What to focus on:
Enabling "Retry On Fail" on every API-calling node
Building one central error workflow that catches failures from all your other workflows
Re-prompting the LLM when it returns malformed JSON
Notifying yourself in Slack or Telegram when a critical workflow breaks
Fallback logic: if the primary model is down, try a secondary one
4. Cost awareness: tokens, pricing, and when AI is overkill
Shipping AI automations without understanding token costs is how you end up with a $3,000 surprise bill on a client project. This skill pays for itself in the first month. VERY IMPORTANT (I lost $400 because of it)
Resources:
1. OpenAI Pricing (free)
Link: https://openai.com/api/pricing
2. Anthropic Pricing (free)
Link: https://www.anthropic.com/pricing
3. OpenAI Tokenizer (interactive, free)
Link: https://platform.openai.com/tokenizer
Paste any text, see exactly how many tokens it is. Use it constantly
What to memorize:
Input tokens are cheap, output tokens are expensive (usually 4-5x more)
Cheap models are "good enough" for classification, routing, and extraction
Use expensive models only for creative generation and complex reasoning
Calculate the monthly cost of a workflow BEFORE you ship it to a client
Practice: Calculate the monthly cost of a workflow that processes 1,000 emails/day, where each email takes 1 classification call on a cheap model and 1 draft generation on a mid-tier model. Get comfortable doing this math (it's what clients trust you for)
5. (Developer path only) Calling OpenAI and Anthropic from Python
Skip this if you're on the non-technical track
If you want the dev track, learn how to make the same LLM calls from Python that you already make from n8n. This becomes useful when you need to do something n8n can't or when a client wants a fully custom backend
Resources:
1. OpenAI API Quickstart (official, free)
Link: https://platform.openai.com/docs/quickstart
2. Anthropic API Quickstart (official, free)
Link: https://docs.anthropic.com/en/docs/get-started
3. OpenAI Cookbook (official, free)
Link: https://cookbook.openai.com/
Runnable notebooks for every common pattern
What to focus on: API keys in env vars (never in code), chat completions, system vs user prompts, temperature=0 for automations, model selection, function / tool calling
Month 2 Milestone:
By the end of this month you should be able to:
Drop AI into any n8n workflow with confidence
Design a clean trigger → AI → action → output chain for any common business task
Handle API failures, bad JSON, and rate limits without your workflow crashing
Estimate the monthly cost of any AI workflow before deploying it
Point at one of your workflows and say "a business would pay me to set this up for them" and mean it
⏩--------------------------------------------------------------------⏪
EARLY MONETIZATION: Your first $500 gig (Month 2-3)
This is the section missing from every "become an AI X in 6 months" article on the internet
Most guides send you to freelance work in Month 6. That's way too late. You can and SHOULD start earning in Month 2 or Month 3, the second you have ONE solid workflow you can replicate
You don't need a portfolio of 10 case studies to get your first gig. You need ONE working workflow, a 3-minute Loom walkthrough, and the willingness to be awkward in sales conversations for about 2 weeks
Where to find your first paying client:
1. Upwork (fastest, best for beginners)
Link: https://www.upwork.com/
Create a profile specifically called "AI Automation Builder" or "n8n Automation Specialist." Apply to jobs tagged "Zapier," "Make," "n8n," "automation," "AI workflow." Price yourself at $30-50/hour for the first 2-3 jobs. Don't argue the rate, just build reviews
2. Fiverr (productized offers)
Link: https://www.fiverr.com/
Create 2-3 fixed-price offers like "I will build you an AI lead qualification workflow in n8n for $200." Fiverr rewards specificity. Hide the word "AI automation" in your tags everywhere
3. Contra (better rates, less competition)
Link: https://contra.com/
Contra is freelance without the race-to-the-bottom pricing. Good for $500-2,000 projects
4. n8n Template Marketplace (inbound leads for free)
Link: https://n8n.io/creators/
Publish a free template in the n8n community. People who import it will DM you asking for help customizing. This is the cheapest lead-gen channel in the entire space
5. Your own X and LinkedIn
Post EVERY workflow you build. Screenshot the canvas, record a 2-min Loom, write a short caption about the problem it solves. By Month 3 you'll have inbound DMs. I promise
What to sell for your first gig:
Don't sell "automation consulting." Don't sell "AI strategy." Don't sell hours. Sell ONE of these:
Lead qualification bot: $300-500. Form submissions → AI scores them against an ICP → high-score leads get routed to a CRM or Slack channel
Email triage assistant: $300-500. Incoming emails get classified by AI, auto-replied to, or routed to the right person
Meeting notes to CRM: $400-700. Meeting transcript → AI extracts action items and CRM field updates → writes to HubSpot automatically
Content repurposer: $250-400. One long-form post → AI generates variants for X, LinkedIn, and a newsletter → posts draft to Notion for approval
All four of these can be built in n8n in a weekend. All four are things businesses will happily pay for
What to deliver with every gig (this is what gets you 5-star reviews)
The n8n workflow itself (exported as JSON so they can import it)
A 3-5 minute Loom walkthrough explaining how it works
A one-page Notion doc with: what it does, how to monitor it, what to do if it breaks
7 days of free support after handoff
Do all four of those and you will get 5-star reviews from people who have never worked with an automation builder before. That social proof is what unlocks the $1,000+ jobs in Months 4-5
The mental rule
Take the gig BEFORE you feel ready. Every single one of my friends making real money in this space took their first gig while they still felt like a fraud. The only way out is through one conversation at a time
⏩--------------------------------------------------------------------⏪
Month 3: Build 1-2 repeatable service workflows
Your goal this month: Build 1-2 polished, repeatable automations that solve a real business problem and that you can resell to multiple clients with light customization
Important warning: do NOT try to build all 6 use cases in this list in one month. That's how beginners burn out. Pick 1-2 and go deep. You only need ONE sellable service to start earning, and two to have real leverage
By the end of this month you should have 1-2 workflows that you can demo in 3 minutes and price on a sales page
How to pick your 1-2 use cases???
Ask yourself:
Which one sounds the most interesting? (You'll put more effort in)
Which one do I already understand the business context for?
Which one do I have free access to the tools for?
Which one is the most in-demand on Upwork right now? (Search and see what people are posting)
Pick based on those. Don't overthink it. Below are the 6 most in-demand use cases in the space, you'll pick 1-2 NOW and come back for the rest later
Use case 1: Lead generation automation (highest demand)
Lead gen is the #1 most requested AI automation in 2026. Every B2B company wants more qualified leads and fewer SDRs
Resources:
1. Apify (free tier)
Link: https://apify.com/
Best platform for scrapers. Thousands of pre-built actors for LinkedIn, Google Maps, Crunchbase
2. Clay (paid, free trial)
Link: https://www.clay.com/
The industry-standard enrichment platform. Learn it, clients will ask
3. Apollo.io API (free tier)
Link: https://docs.apollo.io/
4. Hunter.io API (free tier)
Link: https://hunter.io/api-documentation
Email finding and verification
5. Phantombuster (paid, free trial)
Link: https://phantombuster.com/
Pre-built scrapers for LinkedIn, Twitter, Instagram
Build this one workflow: A pipeline that takes a list of company domains → scrapes website + LinkedIn → enriches with contact info → uses AI to score each against an ICP you define → writes top-scoring leads to a CRM or Google Sheet. Sellable as "Lead Qualification Pipeline — $1,500 one-time + $500/mo"
OR, you can don't even build this, since I've already did it instead of you
Currently, I am building my own product which calls "Close AI". We specializes on building of our own AI SDR (leads generation automation solution for any request)
And we're actively onboarding affiliates to our team who could redirect clients and earn up to 40% per deal (and we already replaced 40 employees in one huge digital company)
We made it on the next level and wrote our own LLM model which is studied on huge datasets of a lot of BD chats, Sales calls etc.
If you're interested to get a solution which nobody has on the market and sell it:
Fill out this Whitelist Form: https://forms.gle/Pj4uSHCNzWLKprzUA
Use case 2: AI-powered cold outreach
This is where AI automation really shines. Generic cold emails are dead. Clients now expect personalized outreach at 1,000+ contacts/week and only automation makes that possible
Resources:
1. Instantly.ai (paid, free trial)
Link: https://instantly.ai/
One of the most popular cold email platforms, full API
2. Smartlead.ai (paid, free trial)
Link: https://smartlead.ai/
Direct competitor with similar API
3. Lemlist API (paid, free trial)
Link: https://developer.lemlist.com/
4. Clay's Cold Email Playbooks (free blog)
Link: https://www.clay.com/learn
Build this one workflow: A lead enters from an Airtable view → n8n pulls their 3 recent LinkedIn posts + company website → an LLM writes a genuinely personalized opener referencing specifics → Instantly or Smartlead sends it → replies come back and get classified by AI (interested / not now / not interested / unsubscribe) → interested leads auto-create a task in the CRM. Sellable as "Personalized Outreach System — $2,000 setup + $1,000/mo"
Use case 3: CRM automation
Every sales team has the same problem: reps don't update the CRM. Automation removes the human dependency and keeps every record clean
Resources:
1. HubSpot API (free tier)
Link: https://developers.hubspot.com/docs/api/overview
The most common CRM you'll integrate with
2. Pipedrive API (free tier)
Link: https://developers.pipedrive.com/
3. Attio API (free tier)
Link: https://developers.attio.com/
New-school CRM that AI-native startups love
Build this one workflow: Every time a meeting happens → transcript goes to an LLM → key fields extracted (next steps, pain points, decision maker, timeline) → HubSpot deal auto-updates → follow-up task assigned to the right person. Sellable as "CRM Autopilot — $1,500 setup + $750/mo"
Use case 4: Content pipelines
Highest margin of all, because output is infinite and clients measure value in pieces shipped
Resources:
1. Blotato API (paid, free trial)
Link: https://www.blotato.com/
Posts to every major platform from one API call
2. Buffer API (paid)
Link: https://buffer.com/developers/api
3. Notion API (free)
Link: https://developers.notion.com/
Where most content briefs live
Build this one workflow: A topic enters from a Notion database → AI generates 6 platform-specific variants (X, LinkedIn, Instagram, TikTok, newsletter, thread) → workflow waits for human approval in Slack → auto-schedules via Buffer at optimal times. Sellable as "AI Content Engine — $2,500 setup + $1,000/mo"
Use case 5: Meeting automation
Every founder and every sales team spends hours in meetings and hours AFTER meetings writing things down. This entire post-meeting process can be fully automated
Resources:
1. Fireflies.ai API (paid, free trial)
Link: https://docs.fireflies.ai/
2. Otter.ai API (paid)
Link: https://otter.ai/api
3. AssemblyAI (free tier)
Link: https://www.assemblyai.com/docs
4. OpenAI Whisper (open source, free)
Link: https://github.com/openai/whisper
Build this one workflow: Zoom meeting ends → Fireflies transcript arrives via webhook → LLM extracts action items, blockers, next meeting date → action items go into Linear or Asana → CRM deal auto-updates → personalized follow-up email draft gets sent to the rep's inbox to review. Sellable as "Meeting Autopilot — $1,200 setup + $600/mo"
Use case 6: Internal knowledge bots
Every company has sprawling internal knowledge that nobody can find. This is the highest-value RAG use case and it sells well
Resources:
1. n8n RAG Templates (free)
Link: https://n8n.io/workflows/?q=rag
Pre-built n8n workflows for document ingestion and Q&A. Start here, you can build a working knowledge bot without writing any code
2. Supabase Vector (free tier)
Link: https://supabase.com/docs/guides/ai
Postgres + pgvector as a managed vector database. Perfect for small-to-mid client projects
3. LlamaIndex (developer track only)
Link: https://docs.llamaindex.ai/
If you want to go deeper and build a fully custom RAG pipeline
4. LangChain RAG Tutorial (developer track only)
Link: https://docs.langchain.com/oss/python/langchain/rag
Build this one workflow: Documents get pulled from Notion or Google Drive → chunked and embedded → stored in Supabase Vector → an internal Slack bot answers questions by retrieving relevant chunks and citing them. Sellable as "Internal Knowledge Bot — $2,500 setup + $500/mo"
Month 3 Milestone
By the end of this month you should be able to:
Pick and ship 1-2 polished, repeatable workflows from the list above
Price each as a productized service with fixed scope and fixed price
Demo each in under 3 minutes on a Loom
Have at least 1 paying client (if you followed the Early Monetization section) or 1 free pilot in exchange for a case study
If you have one paying client by the end of Month 3 (even for $300, means you're already winning)
⏩--------------------------------------------------------------------⏪
Month 4: Add AI agents to your toolbox (carefully)
Your goal this month: Understand what "AI agents" actually are, know when to use them and (more importantly) when NOT to, and add agent-powered workflows to your service offering for the use cases where they genuinely make sense
Warning: most of the "AI agent" content online is hype. You're going to stay grounded. 70% of the time an agent is the wrong choice. You're going to learn when it's the RIGHT choice and that knowledge will make you worth more than 90% of people selling agent services today
What to learn:
1. What agents actually are (and aren't)
An agent is NOT magic. It's a loop: the LLM thinks, picks a tool, the tool runs, the result goes back into the prompt, repeat until the task is done. That's it
Every agent framework (n8n AI Agent node, LangGraph, CrewAI, AutoGen, Lindy, Relevance AI) just wraps this same loop differently
Resources:
1. Anthropic: Building Effective Agents (free — MANDATORY reading)
Link: https://www.anthropic.com/research/building-effective-agents
The single best piece of writing on agents in production. Read this before you build anything agent-related. Not negotiable
2. OpenAI: A Practical Guide to Building Agents (free PDF)
Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
Covers agent patterns, guardrails, and safety
What to focus on:
The perceive → plan → act → observe loop
How a loop terminates (the model says "I'm done" or a max iteration cap hits)
Why agents are just while loops with an LLM making branching decisions
What every framework is actually abstracting away
2. Build your first agent (inside n8n)
For the non-technical path, this is where you go. n8n's AI Agent node handles the loop, the tool calling, and the state management for you. You drag a node, give it a goal, connect it to "tool" sub-workflows, and watch it go
Resources:
1. n8n AI Agent Node Docs (official, free)
Link: https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
The full reference for n8n's agent node. Read the whole thing
2. n8n AI Agent Templates (free)
Link: https://n8n.io/workflows/?categories=AI
Import 3 agent templates, run them, and reverse-engineer how they're wired. Worth a hundred tutorials
What to focus on:
Defining the agent's goal clearly in the system prompt
Exposing the right tools to it (keep it small, 3-5 tools max for your first agent)
Writing tool descriptions that are impossible to misinterpret
Setting a max iteration limit (usually 10-15) so the agent can never loop forever
Adding a human-in-the-loop approval step for any action that's irreversible
Practice project: Build a support agent inside n8n that handles Tier 1 customer tickets. It should:
Classify the ticket (billing, technical, account, feature request)
For known issues, look up the fix in a knowledge base (Notion or Google Drive) and reply
For account questions, pull info via a tool call
For anything else, escalate to Slack with a full context summary
Never send a reply without a confidence check
3. When to use agents vs. simple chains
The most valuable thing you'll learn this month is when NOT to use agents
The decision framework:
Single LLM call: if the task can be solved in one prompt with enough context
Fixed chain: if the steps are predictable and always run in the same order (most workflows!)
Agent: only if the number of steps is genuinely unknown and depends on the input
Resources:
1. Anthropic: "When to use agents" (free)
Link: https://www.anthropic.com/research/building-effective-agents
2. Simon Willison: Designing Agentic Loops (free)
Link: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
Memorize this: A fixed chain of 3 LLM calls will always be faster, cheaper, and more debuggable than an agent that makes 3 calls. Reserve agents for genuinely open-ended tasks like research, multi-step customer support, or flexible sales outreach
4. Human-in-the-loop checkpoints
Most serious business automations need a human approval step somewhere, especially when the agent is about to do something irreversible (send an email, post publicly, update a deal stage, charge a card)
Resources:
1. n8n: Wait Node (free)
Link: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/
n8n's built-in way to pause a workflow until a webhook or time trigger arrives. This is your approval gate
2. Slack Block Kit Builder (free)
Link: https://api.slack.com/block-kit
How to build interactive approval buttons in Slack messages
What to focus on:
Identifying which actions MUST have human approval (send, publish, pay, update)
Building approval UIs in Slack, email, or a lightweight form
Handling approve / reject / edit responses without corrupting state
Timeouts for when no human responds
5. Making agents reliable (the part nobody shows in demos)
Demo agents work. Production agents need actual reliability engineering
What to focus on:
Maximum iteration limits so an agent can never loop forever
Per-tool retry with fallback
Logging every tool call so you can debug what went wrong after the fact
Adding a human escalation path for when the agent gets confused
6. (Developer path only) Python agent frameworks
Skip this if you're on the non-technical track
If you want the dev track, these unlock custom agent work that clients pay more for:
1. LangGraph (free course)
Link: https://academy.langchain.com/courses/intro-to-langgraph
The most widely used agent orchestration framework
2. CrewAI (free, open source)
Link: https://docs.crewai.com/
Multi-agent framework with role-based collaboration
3. AutoGen (Microsoft, free, open source)
Link: https://microsoft.github.io/autogen/
Month 4 Milestone
By the end of this month you should be able to:
Build a working AI agent inside n8n that uses 3-5 tools reliably
Confidently decide whether a task needs a single call, a fixed chain, or an agent
Write tool descriptions that get selected correctly across varied inputs
Add human-in-the-loop approval to any workflow that takes irreversible actions
Know when to say "no, an agent is overkill here" to a client and offer them a simpler solution instead
⏩--------------------------------------------------------------------⏪
Month 5: Make your automations production-ready
Your goal this month: Take everything you built in Months 1-4 and make it survive real clients, real traffic, and real 2am outages
By the end you should be able to deploy, monitor, and hand off an automation to a non-technical client (and confidently promise them uptime and response time)
What to learn:
1. Deployment (use Railway's 1-click n8n first)
Good news: you don't need to learn Docker or DevOps this month. Railway has a 1-click n8n deploy. You click a button, add a custom domain, and you have a production n8n instance in 5 minutes
Do that. Don't overthink it. Docker, reverse proxies, and Kubernetes come LATER, when you have 5+ clients and actually need them
Resources:
1. Railway (free tier, recommended)
Link: https://railway.app/
The fastest way to self-host n8n. Search for "n8n" in their templates and click deploy
2. Render (free tier)
Link: https://render.com/docs/deploy-n8n
Another great one-click option
3. n8n Cloud (hosted, paid)
Link: https://n8n.io/cloud/
The zero-hassle option if a client doesn't want any infra at all. More expensive but no ops work on your end
What to focus on:
Deploying n8n on Railway with a custom domain and HTTPS
Setting environment variables for secrets (never paste keys into the canvas)
Setting up automatic backups
Knowing what to do when it goes down (step 1: check Railway status page)
(Developer path later): Self-hosting n8n with Docker Compose, managed Postgres, and a Caddy reverse proxy. Skip this until you have at least 3-5 clients
2. Logging and monitoring (know when it breaks before your client does)
If you can't see what's happening inside your automation, you can't fix what's broken. And you'll only find out about the breakage when the client emails you at midnight
Resources:
1. n8n Built-in Execution Logs (free)
Link: https://docs.n8n.io/workflows/executions/
n8n's built-in logging is actually very good for most use cases. Master this first before adding anything else
2. Better Stack (free tier)
Link: https://betterstack.com/
Uptime monitoring. Get paged when your n8n instance goes down
3. Langfuse (free tier)
Link: https://langfuse.com/
LLM-specific observability. Traces every prompt, response, token count, and latency. Overkill for Month 5 but good to know exists
What to focus on:
Checking n8n execution logs daily for the first few weeks after deploying
Setting up Better Stack to ping your n8n URL every minute and alert you if it goes down
Alerting yourself in Slack or Telegram when a critical workflow fails
Never finding out about an outage from your client
3. Prompt versioning (don't change prompts randomly in live workflows)
Your prompts are code. They need version control. Random prompt changes in live workflows are how you silently break things
Resources:
1. The boring option (recommended for beginners):
store every prompt in a Notion database or Google Doc, label each version with a date, and always know which version is live
2. Langfuse Prompt Management (free tier)
Link: https://langfuse.com/docs/prompts
Centralized prompt storage with versioning and a built-in playground
What to focus on:
Never editing a live prompt in a client's workflow without testing it first
Keeping the last 3 versions of every prompt so you can roll back
Writing down WHY you changed a prompt every time you do
4. Security basics
The fastest way to lose a client is to expose their API keys or let someone else access their data
Resources:
1. OWASP Top 10 for LLM Apps (free)
Link: https://genai.owasp.org/llm-top-10/
LLM-specific security risks including prompt injection. One hour read
2. n8n Credentials Docs (free)
Link: https://docs.n8n.io/credentials/
How n8n stores API keys securely. Never paste a key into a node parameter (always use the credentials system)
What to focus on:
Never committing API keys to GitHub or any public doc
Using n8n's built-in credentials vault for every API key
Rotating keys if a workflow ever leaks one
Sanitizing any user input before it hits an LLM (prompt injection defense)
Never trusting LLM output to take irreversible actions without human review
5. Documentation and client handoff (the secret to 5x your rates)
The difference between a $500 project and a $5,000 project is often just documentation. If you hand off a beautifully documented workflow with a Loom walkthrough, clients feel taken care of. If you hand off an unlabeled n8n canvas, they feel lost
Resources:
1. Loom (free tier)
Link: https://www.loom.com/
Record walkthrough videos for every workflow. 3-5 minutes each. Clients love these
2. n8n Sticky Notes (free)
Link: https://docs.n8n.io/workflows/sticky-notes/
Use these extensively inside every workflow to explain what each section does
3. Notion Templates for Client Handoffs (free)
Link: https://www.notion.so/templates
Search for "client handoff" and steal shamelessly
What to focus on:
A one-page overview doc per automation: what it does, what triggers it, what it updates, what to do if it breaks
Loom walkthroughs (3-5 min) for every non-trivial workflow
Sticky notes inside every n8n canvas explaining WHY things are set up a certain way
A simple runbook listing the 5 most likely failure modes and how to resolve them
Training the client on how to check the monitoring dashboard themselves
6. Basic SLAs
Once you charge retainers, clients will ask what you're promising and what happens when you miss it. You don't need enterprise contracts. You need clarity
What to focus on:
Uptime commitment (99% is reasonable for automation work)
Response time for issues (reply within X hours, fix within Y)
Scope boundaries (what's included, what's an extra)
Escalation path for urgent failures
Month 5 Milestone
By the end of this month you should be able to:
Deploy any of your workflows to Railway in under 10 minutes
Set up monitoring that alerts you BEFORE clients notice something broke
Hand off a clean package to any client: workflow, Loom, runbook, and a monitoring dashboard
Write and negotiate a basic SLA for retainer work
Sleep peacefully knowing your workflows are being watched
⏩--------------------------------------------------------------------⏪
Month 6: Pick your direction and scale
By this point you have: 1-2 workflows that actually work, at least 1 paying client (hopefully more), a deployed production setup, and the beginnings of a portfolio. Month 6 is about picking which direction you scale in
Three real paths. Pick ONE and go all in
Direction 1: Freelance Automation Builder
Best if you want clients fast and income in 30-60 days
This is the fastest path to real income. You sell workflow builds and retainers directly to SMBs, agencies, coaches, and SaaS founders. Low overhead, high margins, cash in weeks
Focus on:
2-3 repeatable workflow templates (lead gen, cold outreach, content pipeline, support bot)
A simple case study for each with real numbers
Cold outreach to SMBs, agencies, coaches, and SaaS founders
Pricing structure: $500-2k per project to start, move to $1-3k/mo retainers as you get reviews
What to learn this month:
1. Productizing your services
Stop selling hours. Start selling outcomes. "Lead Gen Pipeline Setup — $1,500" converts 10x better than "Custom automation work, hourly rate"
Resources:
1. Productized Services Guide (Pieter Levels, free)
Link: https://nomadlist.com/forum/post/3471
2. Sahil Lavingia's blog (free)
Link: https://sahillavingia.com/
What to focus on:
Pick 2-3 services, write fixed scopes and fixed prices for each
Build a portfolio site (Notion page or Carrd is enough) showcasing only those services
Never say yes to custom work you haven't productized yet
2. Cold outreach and client acquisition
You have to sell. There's no way around it. Good news: you already built the exact tools you'll use for your own outreach during Month 3
Resources:
1. Instantly Blog (free)
Link: https://instantly.ai/blog
2. Nick Saraev (YouTube, free)
Link: https://www.youtube.com/@nicksaraev
Specifically focused on automation agency outreach and sales
What to focus on:
Building a lead list of 500-1000 companies in your target niche
Writing a personalized cold email pitching ONE specific automation with a clear ROI claim
Booking 3-5 discovery calls per week
Closing a "Build First, Pay After" pilot offer to get your first case study
3. Case studies and social proof
One well-documented case study will bring you more clients than 500 outreach emails. Build your first one the moment you ship your first project
What to focus on:
Before/after metrics (time saved, revenue generated, cost reduced)
A clear story: problem → what you built → result
Loom walkthrough of the workflow for visual proof
Client testimonial quote
Direction 2: In-House Automation Builder
Best if you want stability and a salary
This direction is for people who want the safety of a full-time role inside one company, building internal automation systems that save the business time and money
Focus on:
Ops and internal tooling use cases
Connecting AI to existing company stack (Slack, Notion, HubSpot, Salesforce)
Building internal agents and dashboards
Measuring time and cost savings rigorously
What to learn this month:
1. Internal tool building
Resources:
1. Retool (free tier)
Link: https://retool.com/
The standard for building internal tools fast
2. Streamlit (open source, free)
Link: https://streamlit.io/
The fastest way to build Python-powered internal tools
3. Budibase (open source, free)
Link: https://budibase.com/
Open source Retool alternative
What to focus on:
Identifying the highest-value automation targets inside your company
Building simple UIs non-technical employees can actually use
Getting sign-off and resource allocation from stakeholders
2. Measuring ROI properly
In-house builders get promoted based on measurable business impact. If you can't prove your automations saved X hours or $Y, you're invisible
What to focus on:
Tracking before/after metrics for every automation you ship
Presenting numbers in monthly wins docs
Calculating direct (time saved) and indirect (errors reduced, satisfaction improved) impact
Getting stakeholder quotes you can reuse in your next performance review and job search
3. Career positioning
What to focus on:
Writing internal docs and blog posts about your automation wins
Presenting at internal meetings, demo days, all-hands
Sharing (sanitized) case studies on LinkedIn and X
Keeping a "projects built" doc you can show at every performance review
Direction 3: AI Automation Agency
Best if you want to scale beyond trading time for money
This is the highest-ceiling path but also the hardest. You build a team, a repeatable service, and a real business (not just a freelance income)
Focus on:
Building a repeatable service with clear deliverables
Hiring or partnering to fulfill work
Niching down by industry (real estate, e-commerce, recruiting, legal)
Productizing workflows into templates you sell or license
What to learn this month:
1. Building a repeatable service
An agency only works if the same service can be delivered by multiple people the same way. This is what separates agencies from freelancers
Resources:
1. The E-Myth Revisited (book)
Link: https://www.amazon.com/E-Myth-Revisited-Small-Businesses-About/dp/0887307280
The classic on systematizing a services business. Mandatory reading before you hire anyone
2. Built to Sell (book)
Link: https://www.amazon.com/Built-Sell-Creating-Business-Without/dp/1591845823
Specifically about making your agency independent of you
What to focus on:
Documenting every step of your delivery process as SOPs
Defining deliverables and timelines explicitly
Productized pricing: "Lead Gen Package — $3,500 one-time + $750/mo"
2. Niching down
Generalist agencies die. Niche agencies thrive. Pick one industry and own it
What to focus on:
Researching 3-5 industries and picking one where you have context, pricing is high, and the problem is universal
Building niche-specific templates and case studies
Rewriting your portfolio and outreach around that niche
3. Hiring and delegating
Resources:
1. OnlineJobs.ph (paid, international)
Link: https://www.onlinejobs.ph/
2. Upwork (free, global)
Link: https://www.upwork.com/
What to focus on:
Hiring operators first (people who can run existing workflows and talk to clients)
Writing task-level SOPs before hiring anyone
Keeping the first hire part-time until you're sure the work is there
Not hiring until you have at least 3 paying clients
Practice project for Direction 3
Pick one industry (e.g. real estate). Build 3 workflows that solve the 3 biggest repetitive problems in that industry (lead qualification, listing description generation, appointment reminders). Package them as "Real Estate AI Automation Suite" with fixed pricing and a clear deliverables list. This is a sellable product you can take to market on day one
⏩--------------------------------------------------------------------⏪
CONCLUSION
What you can expect after these 6 months???
I'm going to be honest with you, without any "money's mountains"
This roadmap will not make you the next Zapier CEO in 6 months
But it will make you someone who can build, ship, and deploy real AI automations that solve real business problems
And right now, that is exactly what the market is paying for
AI automation demand is not slowing down. LinkedIn's 2026 Jobs on the Rise report puts "AI automation specialist" in the top 5 fastest-growing roles
McKinsey estimates that 60-70% of employee time in most office roles is automatable with current AI + workflow tools
Only about 2% of SMBs have implemented any meaningful AI automation so far, which means 98% of the market is still completely untouched
These are not hype numbers. These are real numbers based on real data (took from Claude kek)
If you go full-time in the US or EU:
1: Junior AI Automation Builders start at $75,000-$110,000
2: Mid-level (2-4 years) sits at $125,000-$180,000
3: Senior builders and automation architects go $180,000-$280,000+
The mid-level band is growing the fastest because companies desperately need people who can ship reliable production automations without supervision
If freelance is more your thing:
4: AI workflow builds go for $500-5,000 per project
5: Monthly retainers start at $500-2,000/mo for basic maintenance and land at $3,000-8,000/mo for active development
6: Hourly rates for specialist automation work are $100-250/hour depending on niche
I personally know freelancers pulling $15,000/month solo just building n8n workflows for SMBs. The work exists and the market is still desperately underserved
And if you go the consulting or agency route:
7: $500-5,000 to set up a single AI automation for a business
8: $1,000-5,000/month for managed automation services
9: $3,000-15,000 to build a full custom agent system
10: $10,000-50,000 for enterprise-grade automation packages
The ceiling is genuinely uncapped. I've seen 2-person automation agencies doing $80k/mo in recurring revenue serving 15-20 clients
These are real numbers from real people doing real work right now in 2026
Now here is what I actually want you to take away from all of this:
Pick one workflow from each month and build it. Not read about it. Not watch a tutorial. Build it, break it, fix it, deploy it, put it on GitHub or in a portfolio site. The builders who get hired are the ones who show what they've built, not what they've studied
Start sharing what you learn. Write about it on X, LinkedIn, anywhere. Teaching is the fastest way to learn and it builds your reputation at the same time. The best clients I've seen come from people who were visible, not from people who applied to 500 job listings
And please don't wait until you feel ready. You will never feel ready. The gap between "I'm learning" and "I'm building" is where most people get stuck forever
Start applying, start freelancing, start offering services the moment you have ONE working automation. Even if it's rough. The market doesn't reward perfection. It rewards people who can ship
6 months is enough to change everything if you actually put in the work
And I really believe each of you reading this can do it
Just never stop building and never stop learning
Hope this was useful for you my fam ❤️