🔄 実践的チームマネジメント：メンバーのタスク管理と進捗確認を効率化する方法 🚀

こんにちは😊
[株式会社プロドウガ](https://qiita.com/organizations/prodouga-com)の@YushiYamamotoです！
[らくらくサイト](https://rakuraku-site.prodouga.com/)の開発・運営を担当しながら、React.js・Next.js専門のフリーランスエンジニアとしても活動しています❗️

エンジニアとしてキャリアを進めていくと、いつかはチームのリーダーやマネージャーとしての役割を担うことになる方も多いでしょう。技術力だけでなく、**チームマネジメント**のスキルが求められる瞬間です。

今回は特に重要な「メンバーのタスク管理と進捗確認」に焦点を当てて、実践的なテクニックをご紹介します。これからチームリーダーになる方も、すでにリーダーとして奮闘中の方も、ぜひ参考にしてみてください！

## 📋 目次

1. [なぜタスク管理と進捗確認が重要なのか](#why-important)
2. [効果的なタスク管理の基本](#task-management-basics)
3. [進捗確認のベストプラクティス](#progress-tracking)
4. [おすすめのタスク管理ツール](#recommended-tools)
5. [タスク管理のためのコード例](#code-examples)
6. [よくある問題と解決策](#problems-solutions)
7. [まとめ](#conclusion)

<a id="why-important"></a>
## 📊 なぜタスク管理と進捗確認が重要なのか

チーム開発において、タスク管理と進捗確認が適切に行われないと次のような問題が発生します：

- 🔸 **デッドラインの遅延**：誰が何をいつまでにやるべきかが不明確
- 🔸 **リソースの無駄遣い**：同じタスクを複数人が重複して行う
- 🔸 **コミュニケーションの齟齬**：タスクの依存関係が把握できない
- 🔸 **モチベーションの低下**：進捗が見えず、達成感を得られない

逆に言えば、適切なタスク管理と進捗確認によって、プロジェクトの **透明性** と **予測可能性** が向上し、チームの生産性とモチベーションが高まります。

:::note info
ある調査によると、明確なタスク管理システムを導入したチームは、そうでないチームと比較して最大40%の生産性向上が見られるとのことです。
:::

<a id="task-management-basics"></a>
## 🗂 効果的なタスク管理の基本

### 1. タスクの分解と優先順位付け

大きな作業を小さなタスクに分解することは、アジャイル開発の基本です。

```mermaid
graph TD
    A[大きな機能] --> B[ユーザーストーリー1]
    A --> C[ユーザーストーリー2]
    B --> D[タスク1.1]
    B --> E[タスク1.2]
    C --> F[タスク2.1]
    C --> G[タスク2.2]
```

タスクを分解する際のポイント：

- 📌 1つのタスクは理想的には半日〜2日で完了できるサイズに
- 📌 明確な完了条件（Definition of Done）を設定
- 📌 依存関係を明確にし、ボトルネックを事前に特定
- 📌 優先度は「重要性×緊急性」で評価

### 2. SMART原則によるタスク設定

効果的なタスクは SMART 原則に従って設定すると良いでしょう：

- **S**pecific（具体的）: 何をするのか明確に
- **M**easurable（測定可能）: 完了したかどうか判断できる
- **A**chievable（達成可能）: 現実的に達成できる範囲
- **R**elevant（関連性）: プロジェクト目標に関連している
- **T**ime-bound（期限付き）: いつまでに完了するか明確

悪い例と良い例を比較してみましょう：

```
❌ 悪い例：「ログイン機能を実装する」
✅ 良い例：「ユーザー名とパスワードによる認証機能を実装し、RSpecでテストを作成する。10/15までに完了させる」
```

<a id="progress-tracking"></a>
## 🔄 進捗確認のベストプラクティス

### 1. デイリースタンドアップの効果的な実施

アジャイル開発で一般的な「デイリースタンドアップ」は、短時間（15分以内）で以下の3点を共有します：

1. 昨日やったこと
2. 今日やること
3. 障害になっていること（ブロッカー）

ただし、単なる報告会にしないことが重要です。特に **ブロッカーの解消** に焦点を当て、チームで解決策を見つける場にしましょう。

### 2. 視覚的な進捗管理

カンバンボードなどを使った視覚的な進捗管理は非常に効果的です：

```mermaid
graph LR
    A[未着手] --> B[進行中]
    B --> C[レビュー待ち]
    C --> D[完了]
```

視覚的な管理の利点：
- 👁️ チーム全体の状況が一目でわかる
- 👁️ ボトルネックが視覚的に識別できる（特定の列にタスクが溜まる）
- 👁️ 成果が目に見えることでモチベーションが向上

### 3. 効果的な1on1ミーティング

定期的な1on1ミーティングは、進捗確認だけでなくメンバーの成長や悩みを把握する重要な機会です：

- ⏱️ 定期的に（週1回など）30分程度の時間を確保
- 🗣️ 進捗確認だけでなく、課題やキャリア目標も話し合う
- 📝 アクションアイテムを明確にし、次回までのフォローアップを計画

<a id="recommended-tools"></a>
## 🛠 おすすめのタスク管理ツール

現代のチーム開発には、適切なツールの選択が欠かせません。

### 1. 総合プロジェクト管理ツール

| ツール名 | 特徴 | 向いているチーム |
|---------|------|----------------|
| Jira | 詳細な設定、カスタマイズ性が高い | 中〜大規模開発チーム |
| Trello | シンプルで直感的なカンバンボード | 小規模チーム、スタートアップ |
| Asana | タスクとコミュニケーションの統合 | マルチプロジェクト、部署横断チーム |
| ClickUp | 高いカスタマイズ性とテンプレート | 多様な業務フローを持つチーム |

### 2. エンジニア特化ツール

GitHubやGitLabのIssuesとProjects機能は、コードリポジトリと直接連携できるため、エンジニアチームに特に便利です。

例えば、GitHub Projectsでは以下のようなコマンドでIssueを自動的に進捗管理できます：

```bash
# PRをマージしたときに関連Issueを自動的に「Done」に移動させる例
gh pr merge --auto --merge
```

また、GitHub Actionsを使ってタスク管理を自動化することも可能です：

<details><summary>GitHub Actionsによるタスク自動化例</summary>

```yaml
name: Auto Assign to Project

on:
  issues:
    types: [opened]
  pull_request:
    types: [opened]

jobs:
  assign_to_project:
    runs-on: ubuntu-latest
    steps:
      - name: Assign to Project
        uses: actions/github-script@v6
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const issue = context.payload.issue || context.payload.pull_request;
            
            // プロジェクトIDとステータスフィールドID
            const projectId = 'YOUR_PROJECT_ID';
            const statusFieldId = 'YOUR_STATUS_FIELD_ID';
            
            // GraphQLを使ってプロジェクトにissueを追加
            await github.graphql(`
              mutation {
                addProjectV2ItemById(input: {
                  projectId: "${projectId}"
                  contentId: "${issue.node_id}"
                }) {
                  item {
                    id
                  }
                }
              }
            `);
```

</details>

### 3. コミュニケーションツールとの連携

Slack、Microsoft Teamsなどのコミュニケーションツールと連携することで、タスクの更新をリアルタイムで共有できます：

```javascript
// Slackに進捗状況を通知するNode.jsコード例
const { WebClient } = require('@slack/web-api');
const slack = new WebClient(process.env.SLACK_TOKEN);

async function notifyTaskUpdate(taskId, status, assignee) {
  try {
    await slack.chat.postMessage({
      channel: '#project-updates',
      text: `🔄 タスク #${taskId} が「${status}」に更新されました (担当: @${assignee})`,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: `🔄 *タスク #${taskId}* が「*${status}*」に更新されました`
          }
        },
        {
          type: "context",
          elements: [
            {
              type: "mrkdwn",
              text: `担当: @${assignee} | 更新日時: ${new Date().toLocaleString('ja-JP')}`
            }
          ]
        }
      ]
    });
    console.log('Message posted to Slack');
  } catch (error) {
    console.error('Error posting to Slack:', error);
  }
}

// 使用例
notifyTaskUpdate('TASK-123', '検証中', 'yamamoto');
```

<a id="code-examples"></a>
## 💻 タスク管理のためのコード例

### 1. シンプルなTodoリストアプリの例（React）

チーム内で使える簡易的なTodoリストをReactで実装してみましょう：

<details><summary>シンプルなReactタスク管理コンポーネント</summary>

```jsx
import React, { useState, useEffect } from 'react';
import './TaskManager.css';

const TaskManager = () => {
  // タスクの状態管理
  const [tasks, setTasks] = useState(() => {
    const savedTasks = localStorage.getItem('tasks');
    return savedTasks ? JSON.parse(savedTasks) : [];
  });
  
  // 入力フォームの状態
  const [newTask, setNewTask] = useState('');
  const [newAssignee, setNewAssignee] = useState('');
  const [newDueDate, setNewDueDate] = useState('');
  
  // タスクの状態オプション
  const statusOptions = ['未着手', '進行中', 'レビュー待ち', '完了'];
  
  // ローカルストレージに保存
  useEffect(() => {
    localStorage.setItem('tasks', JSON.stringify(tasks));
  }, [tasks]);
  
  // タスク追加
  const handleAddTask = () => {
    if (!newTask.trim()) return;
    
    const task = {
      id: Date.now(),
      title: newTask,
      status: '未着手',
      assignee: newAssignee || '未割当',
      dueDate: newDueDate || '期限なし',
      createdAt: new Date().toISOString()
    };
    
    setTasks([...tasks, task]);
    setNewTask('');
    setNewAssignee('');
    setNewDueDate('');
  };
  
  // タスクのステータス変更
  const handleStatusChange = (id, newStatus) => {
    setTasks(tasks.map(task => 
      task.id === id ? { ...task, status: newStatus } : task
    ));
  };
  
  // タスク削除
  const handleDeleteTask = (id) => {
    setTasks(tasks.filter(task => task.id !== id));
  };
  
  return (
    <div className="task-manager">
      <h2>チームタスク管理ボード</h2>
      
      {/* タスク入力フォーム */}
      <div className="task-form">
        <input
          type="text"
          placeholder="新しいタスクを入力"
          value={newTask}
          onChange={(e) => setNewTask(e.target.value)}
        />
        <input
          type="text"
          placeholder="担当者"
          value={newAssignee}
          onChange={(e) => setNewAssignee(e.target.value)}
        />
        <input
          type="date"
          value={newDueDate}
          onChange={(e) => setNewDueDate(e.target.value)}
        />
        <button onClick={handleAddTask}>追加</button>
      </div>
      
      {/* カンバンボード */}
      <div className="kanban-board">
        {statusOptions.map(status => (
          <div key={status} className="status-column">
            <h3>{status}</h3>
            {tasks.filter(task => task.status === status).map(task => (
              <div key={task.id} className="task-card">
                <h4>{task.title}</h4>
                <p>担当: {task.assignee}</p>
                <p>期限: {task.dueDate}</p>
                <select
                  value={task.status}
                  onChange={(e) => handleStatusChange(task.id, e.target.value)}
                >
                  {statusOptions.map(option => (
                    <option key={option} value={option}>{option}</option>
                  ))}
                </select>
                <button onClick={() => handleDeleteTask(task.id)}>削除</button>
              </div>
            ))}
          </div>
        ))}
      </div>
    </div>
  );
};

export default TaskManager;
```

</details>

このコンポーネントは、シンプルなカンバンボードを実装しています。実際のプロジェクトでは、バックエンドとの連携やチーム間の同期機能が必要になるでしょう。

### 2. 進捗レポート生成スクリプト（Node.js）

週次や月次の進捗レポートを自動生成するスクリプトの例：

```javascript
// report-generator.js
const fs = require('fs');
const path = require('path');

// データ取得の想定関数（実際にはAPIやDBから取得）
function fetchTaskData(startDate, endDate) {
  // 実際のデータ取得ロジックに置き換える
  return [
    { id: 1, title: 'APIエンドポイント実装', status: '完了', assignee: '山田', completedAt: '2023-10-05' },
    { id: 2, title: 'フロントエンドUI改修', status: '進行中', assignee: '鈴木', progress: 75 },
    { id: 3, title: 'パフォーマンス最適化', status: '未着手', assignee: '佐藤' },
    // 他のタスク...
  ];
}

function generateWeeklyReport(startDate, endDate, teamName) {
  const tasks = fetchTaskData(startDate, endDate);
  
  // 統計の計算
  const completed = tasks.filter(t => t.status === '完了').length;
  const inProgress = tasks.filter(t => t.status === '進行中').length;
  const notStarted = tasks.filter(t => t.status === '未着手').length;
  const totalTasks = tasks.length;
  const completionRate = (completed / totalTasks * 100).toFixed(1);
  
  // マークダウンレポートの生成
  let report = `# ${teamName} 週次進捗レポート\n\n`;
  report += `**期間**: ${startDate} 〜 ${endDate}\n\n`;
  report += `## 📊 概要\n\n`;
  report += `- 総タスク数: ${totalTasks}\n`;
  report += `- 完了: ${completed} (${completionRate}%)\n`;
  report += `- 進行中: ${inProgress}\n`;
  report += `- 未着手: ${notStarted}\n\n`;
  
  report += `## ✅ 完了したタスク\n\n`;
  tasks.filter(t => t.status === '完了').forEach(task => {
    report += `- ${task.title} (担当: ${task.assignee}, 完了日: ${task.completedAt})\n`;
  });
  
  report += `\n## 🔄 進行中のタスク\n\n`;
  tasks.filter(t => t.status === '進行中').forEach(task => {
    report += `- ${task.title} (担当: ${task.assignee}, 進捗: ${task.progress || 0}%)\n`;
  });
  
  // レポートファイルの保存
  const filename = `${teamName.toLowerCase().replace(/\s+/g, '-')}-report-${endDate}.md`;
  const filePath = path.join(__dirname, 'reports', filename);
  
  fs.writeFileSync(filePath, report);
  console.log(`レポートが生成されました: ${filePath}`);
  
  return { filePath, completionRate };
}

// 使用例
const today = new Date();
const lastWeek = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000);
const startDate = lastWeek.toISOString().split('T')[0];
const endDate = today.toISOString().split('T')[0];

generateWeeklyReport(startDate, endDate, 'フロントエンドチーム');
```

このスクリプトを定期実行すれば、チームの進捗状況を自動的にレポート化できます。

### 3. 進捗可視化ダッシュボード（React + Chart.js）

データを視覚的に表示するダッシュボードの例：

```jsx
import React, { useState, useEffect } from 'react';
import { Line, Bar, Pie } from 'react-chartjs-2';
import { Chart, registerables } from 'chart.js';
Chart.register(...registerables);

const TeamDashboard = () => {
  const [dashboardData, setDashboardData] = useState(null);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    // 実際はAPIからデータ取得
    const fetchData = async () => {
      try {
        // モックデータ
        const data = {
          weeklyCompletion: [65, 59, 80, 81, 56, 55, 72],
          tasksByStatus: {
            '未着手': 8,
            '進行中': 12,
            'レビュー待ち': 6,
            '完了': 24
          },
          tasksByAssignee: {
            '山田': 10,
            '鈴木': 15,
            '佐藤': 12,
            '田中': 13
          }
        };
        
        setDashboardData(data);
        setLoading(false);
      } catch (error) {
        console.error('データ取得エラー:', error);
        setLoading(false);
      }
    };
    
    fetchData();
  }, []);
  
  if (loading) return <div>Loading dashboard...</div>;
  if (!dashboardData) return <div>データが利用できません</div>;
  
  // 週間完了タスクのグラフデータ
  const weeklyData = {
    labels: ['Week 1', 'Week 2', 'Week 3', 'Week 4', 'Week 5', 'Week 6', 'Week 7'],
    datasets: [
      {
        label: '完了タスク数',
        data: dashboardData.weeklyCompletion,
        fill: false,
        backgroundColor: 'rgb(75, 192, 192)',
        borderColor: 'rgba(75, 192, 192, 0.2)',
      },
    ],
  };
  
  // ステータス別タスク数
  const statusData = {
    labels: Object.keys(dashboardData.tasksByStatus),
    datasets: [
      {
        label: 'タスク数',
        data: Object.values(dashboardData.tasksByStatus),
        backgroundColor: [
          'rgba(255, 99, 132, 0.6)',
          'rgba(54, 162, 235, 0.6)',
          'rgba(255, 206, 86, 0.6)',
          'rgba(75, 192, 192, 0.6)',
        ],
        borderWidth: 1,
      },
    ],
  };
  
  // 担当者別タスク数
  const assigneeData = {
    labels: Object.keys(dashboardData.tasksByAssignee),
    datasets: [
      {
        label: 'タスク数',
        data: Object.values(dashboardData.tasksByAssignee),
        backgroundColor: [
          'rgba(255, 99, 132, 0.6)',
          'rgba(54, 162, 235, 0.6)',
          'rgba(255, 206, 86, 0.6)',
          'rgba(75, 192, 192, 0.6)',
        ],
      },
    ],
  };
  
  return (
    <div className="dashboard">
      <h2>チーム進捗ダッシュボード</h2>
      
      <div className="dashboard-grid">
        <div className="chart-container">
          <h3>週間完了タスク推移</h3>
          <Line data={weeklyData} />
        </div>
        
        <div className="chart-container">
          <h3>ステータス別タスク数</h3>
          <Pie data={statusData} />
        </div>
        
        <div className="chart-container">
          <h3>担当者別タスク割り当て</h3>
          <Bar data={assigneeData} />
        </div>
      </div>
    </div>
  );
};

export default TeamDashboard;
```

<a id="problems-solutions"></a>
## 🚨 よくある問題と解決策

### 1. タスクの見積もり精度が低い

#### 問題
開発タスクの工数見積もりが甘く、常にスケジュールが遅延する。

#### 解決策
- ⏱️ **プランニングポーカー**：チームメンバー全員で見積もりを出し合う手法を導入
- 📊 **実績データの活用**：過去の類似タスクの実績時間を参考にする
- 🔄 **バッファの確保**：見積もり時間に適切なバッファ（20-30%）を追加
- 🧩 **タスクの細分化**：大きすぎるタスクはさらに細かく分割して見積もり精度を向上

```mermaid
graph TD
    A[大きなタスク] --> B[見積もりが困難]
    A --> C[細分化したタスク群]
    C --> D[見積もりが容易に]
    D --> E[精度向上]
```

### 2. タスクの「進行中」状態が長期化

#### 問題
多くのタスクが「進行中」状態で停滞し、なかなか完了しない。

#### 解決策
- 🚦 **WIP（Work In Progress）制限**：同時に進行中のタスク数に上限を設ける
- 🔍 **デイリーでのブロッカー確認**：障害となっている問題を早期に発見し解決
- 👥 **ペアプログラミング**：難しいタスクはペアで取り組み、停滞を防ぐ
- 🏆 **小さな勝利を祝う**：タスク完了を積極的に評価し、モチベーションを維持

:::note warn
カンバンボードの「進行中」列に多くのタスクが滞留している場合は、チームがオーバーコミットしている可能性があります。WIP制限を設けて、一度に取り組むタスク数を制限しましょう。
:::

### 3. チームメンバー間でのタスク偏り

#### 問題
特定のメンバーにタスクが集中し、他のメンバーは手持ち無沙汰になる。

#### 解決策
- 📋 **スキルマトリックス作成**：メンバーのスキルを可視化し、適切なタスク分配の参考にする
- 🔄 **ローテーション制**：特定の領域を特定の人だけが担当しない仕組みを作る
- 🧠 **知識共有セッション**：専門知識を持つメンバーから他メンバーへの知識移転を促進
- 🤝 **メンタリング**：経験豊富なメンバーが新メンバーをサポートする体制

スキルマトリックスの例：

```markdown
| メンバー | フロントエンド | バックエンド | DB設計 | インフラ | テスト |
|--------|-------------|-----------|-------|-------|-------|
| 山田    | ⭐⭐⭐      | ⭐⭐      | ⭐     | ⭐     | ⭐⭐   |
| 鈴木    | ⭐         | ⭐⭐⭐     | ⭐⭐⭐  | ⭐⭐    | ⭐     |
| 佐藤    | ⭐⭐        | ⭐        | ⭐⭐    | ⭐⭐⭐  | ⭐⭐⭐  |
```

### 4. コミュニケーション不足による混乱

#### 問題
タスクの依存関係や変更点が適切に共有されず、重複作業や手戻りが発生する。

#### 解決策
- 📢 **情報共有の仕組み化**：毎日のスタンドアップや週次レビューの定例化
- 📝 **ドキュメンテーションの徹底**：意思決定や設計変更の記録を残す文化を作る
- 🔗 **タスク間の依存関係の可視化**：関連タスクを明示的にリンクさせる
- 💬 **チャットツールの効果的活用**：専用チャンネルでのリアルタイム情報共有

例えば、GitHubのPull Requestには関連Issueを記載する習慣を作ることで、コードとタスクの関連性を明確にできます：

```markdown
## 関連Issue
- Fixes #123
- Related to #456

## 変更内容
- ユーザー認証プロセスの最適化
- セッション管理の改善

## レビューのポイント
- 認証失敗時のエラーハンドリングをチェックしてください
- セキュリティ面での問題がないか確認お願いします
```

### 5. タスク管理が形骸化する

#### 問題
ツールは導入したものの、更新されず、実態とタスク管理システムに乖離が生じる。

#### 解決策
- 🔄 **更新の習慣化**：タスク状態の更新をルーティン化（朝一番、終業時など）
- 🤖 **自動化の活用**：可能な限り、ステータス更新を自動化（GitHubアクションなど）
- 👑 **リーダーによる率先垂範**：マネージャー自身が積極的にツールを活用
- 🎯 **シンプルさの追求**：過度に複雑なプロセスは避け、最小限の手順で管理

例えば、以下のような簡単なシェルスクリプトで、今日の作業開始時に未完了タスクを確認するリマインドを設定できます：

```bash
#!/bin/bash
# daily-tasks-reminder.sh

# JIRAから担当タスクを取得（curlコマンドは実際の環境に合わせて修正）
echo "📋 今日の未完了タスク一覧"
echo "=========================="
curl -s -u username:password "https://your-jira.com/rest/api/2/search?jql=assignee=currentUser()+AND+status+not+in+(Done,Closed)&fields=summary,status,priority" | jq '.issues[] | "[\(.fields.status.name)] \(.fields.summary)"'
echo "=========================="
echo "🚀 素晴らしい一日を！"
```

このスクリプトを`.bashrc`や`.zshrc`に追加すれば、ターミナル起動時に自動実行されます。

<a id="conclusion"></a>
## 📌 まとめ

効果的なタスク管理と進捗確認は、チーム開発の成功に不可欠です。ポイントをまとめると：

1. **タスクの適切な分解と定義**：
   - SMART原則に基づいたタスク設定
   - 明確な完了条件（Definition of Done）の設定

2. **視覚的な進捗管理**：
   - カンバンボードなどを活用した状況の可視化
   - ボトルネックの早期発見と対応

3. **適切なツールの活用**：
   - チームの規模や特性に合ったツールの選定
   - 自動化による管理負担の軽減

4. **コミュニケーションの重視**：
   - 定期的なミーティングによる情報共有
   - ブロッカーの早期発見と解決

5. **継続的な改善**：
   - 振り返りによるプロセスの最適化
   - メンバーからのフィードバックの反映

:::note info
タスク管理は単なる「管理」ではなく「支援」であることを忘れないでください。目的はチームの生産性を高め、メンバーが最大限の力を発揮できる環境を作ることです。
:::

チームリーダーとして最も重要なのは、「タスク」だけでなく「人」に注目することです。メンバーの成長や働きやすさに配慮しながら、プロジェクトを成功に導きましょう。

皆さんのチームマネジメントが、より効果的で楽しいものになることを願っています！ご質問やご意見があれば、コメント欄でお待ちしています。

## 参考リンク

- [Agile Manifesto](https://agilemanifesto.org/iso/ja/manifesto.html)
- [カンバン方式とは - Atlassian](https://www.atlassian.com/ja/agile/kanban)
- [GitHubでのプロジェクト管理](https://docs.github.com/ja/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects)
- [効果的な1on1ミーティングの進め方](https://www.manager-tools.com/2005/07/the-single-most-effective-management-tool-part-1)

# 最後に：業務委託のご相談を承ります
私は業務委託エンジニアとしてWEB制作やシステム開発を請け負っています。最新技術を活用したレスポンシブなWebサイト制作、インタラクティブなアプリケーション開発、API連携など幅広いご要望に対応可能です。

「課題解決に向けた即戦力が欲しい」「高品質なWeb制作を依頼したい」という方は、お気軽にご相談ください。一緒にビジネスの成長を目指しましょう！

👉 [ポートフォリオ](https://yushiyamamoto.vercel.app/)

🌳 [らくらくサイト](https://rakuraku-site.prodouga.com/)