5m man money machine material management

หลักการ 5M คืออะไร

5M เป็นกรอบแนวคิดในการบริหารจัดการที่ครอบคลุม 5 ปัจจัยหลักที่ส่งผลต่อความสำเร็จขององค์กร ได้แก่ Man (คน), Money (เงิน), Machine (เครื่องจักร/เทคโนโลยี), Material (วัตถุดิบ/ทรัพยากร) และ Management (การจัดการ) ทั้ง 5 ปัจจัยเชื่อมโยงกัน ถ้าปัจจัยใดอ่อนจะกระทบปัจจัยอื่นทั้งหมด

ในบริบทของ IT และเทคโนโลยี 5M ถูกปรับใช้กับการบริหารโครงการซอฟต์แวร์ DevOps และ Digital Transformation Man คือ Developer Team, Money คือ Cloud Budget, Machine คือ Infrastructure, Material คือ Code และ APIs, Management คือ Agile Methodology

Python Dashboard สำหรับวิเคราะห์ 5M

# five_m_dashboard.py — 5M Analysis Dashboard
import json
from dataclasses import dataclass, field
from typing import Dict, List
from datetime import datetime

@dataclass
class MFactor:
    """ปัจจัย M แต่ละตัว"""
    name: str
    category: str
    score: float           # 0-100
    weight: float          # น้ำหนัก (รวม 5 ตัว = 1.0)
    metrics: Dict[str, float] = field(default_factory=dict)
    issues: List[str] = field(default_factory=list)
    actions: List[str] = field(default_factory=list)

class FiveMAnalyzer:
    """วิเคราะห์ 5M สำหรับองค์กร"""

    def __init__(self):
        self.factors: Dict[str, MFactor] = {}

    def add_factor(self, factor: MFactor):
        self.factors[factor.category] = factor

    def calculate_overall_score(self) -> float:
        """คำนวณคะแนนรวม (Weighted Average)"""
        total = sum(f.score * f.weight for f in self.factors.values())
        return round(total, 1)

    def identify_weakest(self) -> MFactor:
        """หาปัจจัยที่อ่อนที่สุด"""
        return min(self.factors.values(), key=lambda f: f.score)

    def generate_report(self):
        """สร้างรายงาน 5M Analysis"""
        overall = self.calculate_overall_score()
        weakest = self.identify_weakest()

        print("=" * 60)
        print(f"5M Analysis Report — {datetime.now():%Y-%m-%d}")
        print("=" * 60)

        print(f"\nOverall Score: {overall}/100")
        print(f"Weakest Factor: {weakest.name} ({weakest.score}/100)")

        print(f"\n{'Factor':<15} {'Score':<8} {'Weight':<8} {'Weighted':<10} {'Status'}")
        print("-" * 55)

        for f in self.factors.values():
            weighted = f.score * f.weight
            status = "OK" if f.score >= 70 else ("WARN" if f.score >= 50 else "CRITICAL")
            print(f"{f.name:<15} {f.score:<8.0f} {f.weight:<8.1%} "
                  f"{weighted:<10.1f} {status}")

        # Issues
        print(f"\nTop Issues:")
        for f in sorted(self.factors.values(), key=lambda x: x.score):
            for issue in f.issues[:2]:
                print(f"  [{f.name}] {issue}")

        # Actions
        print(f"\nRecommended Actions:")
        for f in sorted(self.factors.values(), key=lambda x: x.score):
            for action in f.actions[:2]:
                print(f"  [{f.name}] {action}")

    def to_json(self) -> str:
        """Export เป็น JSON"""
        data = {
            "timestamp": datetime.now().isoformat(),
            "overall_score": self.calculate_overall_score(),
            "factors": {}
        }
        for key, f in self.factors.items():
            data["factors"][key] = {
                "name": f.name, "score": f.score,
                "weight": f.weight, "metrics": f.metrics,
                "issues": f.issues, "actions": f.actions,
            }
        return json.dumps(data, ensure_ascii=False, indent=2)

# === ตัวอย่าง IT Project Analysis ===
analyzer = FiveMAnalyzer()

analyzer.add_factor(MFactor(
    name="Man (บุคลากร)", category="man", score=72, weight=0.25,
    metrics={"team_size": 8, "avg_experience_years": 3.5,
             "retention_rate": 85, "training_hours": 40},
    issues=["ขาด Senior DevOps Engineer",
            "Training Budget ไม่เพียงพอ"],
    actions=["รับสมัคร Senior DevOps 1 ตำแหน่ง",
             "เพิ่ม Training Budget 20%"],
))

analyzer.add_factor(MFactor(
    name="Money (งบประมาณ)", category="money", score=65, weight=0.20,
    metrics={"monthly_cloud_cost": 150000, "license_cost": 50000,
             "salary_budget": 800000, "roi": 2.5},
    issues=["Cloud Cost เพิ่ม 30% จากปีก่อน",
            "ไม่มี Cost Optimization Plan"],
    actions=["ทำ Cloud Cost Optimization (Reserved Instances)",
             "ใช้ Spot Instances สำหรับ Non-critical Workloads"],
))

analyzer.add_factor(MFactor(
    name="Machine (เทคโนโลยี)", category="machine", score=80, weight=0.20,
    metrics={"uptime": 99.5, "ci_cd_pipeline": True,
             "monitoring": True, "auto_scaling": True},
    issues=["CI/CD Pipeline ช้า (15 นาที/Build)"],
    actions=["ปรับ CI/CD ให้ Build เร็วขึ้นด้วย Caching"],
))

analyzer.add_factor(MFactor(
    name="Material (ทรัพยากร)", category="material", score=68, weight=0.15,
    metrics={"test_coverage": 65, "code_quality_score": 72,
             "tech_debt_ratio": 15, "documentation": 60},
    issues=["Test Coverage ต่ำกว่า 80% เป้าหมาย",
            "Technical Debt 15% ต้องลด"],
    actions=["เพิ่ม Unit Tests ให้ถึง 80%",
             "จัด Sprint สำหรับ Technical Debt Reduction"],
))

analyzer.add_factor(MFactor(
    name="Management (จัดการ)", category="management", score=75, weight=0.20,
    metrics={"velocity": 45, "lead_time_days": 5,
             "sprint_completion": 82, "team_satisfaction": 78},
    issues=["Sprint Completion Rate ต่ำกว่า 85%"],
    actions=["ปรับ Sprint Planning ให้สมจริงมากขึ้น",
             "ลด Scope Creep ด้วย Change Request Process"],
))

analyzer.generate_report()

Fishbone Diagram ร่วมกับ 5M

# fishbone_5m.py — Fishbone Diagram Analysis ด้วย 5M
from collections import defaultdict

class FishboneDiagram:
    """Fishbone Diagram (Ishikawa) ด้วย 5M Categories"""

    def __init__(self, problem_statement):
        self.problem = problem_statement
        self.causes = defaultdict(list)

    def add_cause(self, category, cause, sub_causes=None):
        """เพิ่มสาเหตุ"""
        entry = {"cause": cause, "sub_causes": sub_causes or []}
        self.causes[category].append(entry)

    def display(self):
        """แสดง Fishbone Diagram"""
        print(f"\n{'='*60}")
        print(f"FISHBONE DIAGRAM (5M Analysis)")
        print(f"Problem: {self.problem}")
        print(f"{'='*60}")

        categories = ["Man", "Money", "Machine", "Material", "Management"]

        for cat in categories:
            if cat in self.causes:
                print(f"\n  [{cat}]")
                for entry in self.causes[cat]:
                    print(f"    ├── {entry['cause']}")
                    for sub in entry["sub_causes"]:
                        print(f"    │   └── {sub}")

        print(f"\n  ──────────► [{self.problem}]")

    def get_priority_causes(self, top_n=5):
        """หาสาเหตุที่น่าจะมีผลกระทบมากที่สุด"""
        all_causes = []
        for cat, entries in self.causes.items():
            for entry in entries:
                all_causes.append({
                    "category": cat,
                    "cause": entry["cause"],
                    "sub_count": len(entry["sub_causes"]),
                })

        # Sort by number of sub-causes (proxy for impact)
        return sorted(all_causes, key=lambda x: x["sub_count"],
                      reverse=True)[:top_n]

# ตัวอย่าง: วิเคราะห์ปัญหา "Deployment ล่าช้า"
fb = FishboneDiagram("Deployment ล่าช้าเกิน SLA")

fb.add_cause("Man", "Developer ไม่คุ้นเคย Kubernetes",
    ["ไม่มี Training Program", "เอกสารไม่ครบ"])
fb.add_cause("Man", "ทีม DevOps มีคนน้อย",
    ["รับคนไม่ทัน", "Workload สูง", "Burnout"])

fb.add_cause("Money", "Budget สำหรับ Tools ไม่พอ",
    ["ใช้ Free Tier ที่มี Limitations"])
fb.add_cause("Money", "ไม่มี Budget สำหรับ Staging Environment")

fb.add_cause("Machine", "CI/CD Pipeline ช้า",
    ["Build Time 15 นาที", "ไม่มี Caching", "Runner ไม่พอ"])
fb.add_cause("Machine", "Staging Environment ไม่เสถียร",
    ["Resource ไม่พอ", "Config ต่างจาก Production"])

fb.add_cause("Material", "Test Coverage ต่ำ",
    ["ไม่มี Integration Tests", "E2E Tests ช้า"])
fb.add_cause("Material", "Docker Image ใหญ่เกินไป",
    ["ไม่ใช้ Multi-stage Build", "Dependencies เยอะ"])

fb.add_cause("Management", "Release Process ไม่ชัดเจน",
    ["ไม่มี Runbook", "Manual Steps เยอะ", "ไม่มี Rollback Plan"])
fb.add_cause("Management", "Communication Gap",
    ["ไม่มี Status Update", "ไม่มี Incident Channel"])

fb.display()

priorities = fb.get_priority_causes()
print("\nPriority Causes:")
for p in priorities:
    print(f"  [{p['category']}] {p['cause']} ({p['sub_count']} sub-causes)")

5M Checklist สำหรับ IT Projects

# 5m_checklist.py — 5M Readiness Checklist
checklist = {
    "Man": [
        ("มี Project Manager ที่มีประสบการณ์", True),
        ("Developer มีทักษะตรงกับ Tech Stack", True),
        ("มี DevOps/SRE Engineer", False),
        ("มี QA Engineer", True),
        ("มี Training Plan สำหรับเทคโนโลยีใหม่", False),
        ("Backup Personnel สำหรับ Key Roles", False),
        ("Team Satisfaction Score > 70%", True),
    ],
    "Money": [
        ("Budget สำหรับ Cloud Infrastructure", True),
        ("Budget สำหรับ Software Licenses", True),
        ("Contingency Budget 10-15%", False),
        ("Cost Monitoring และ Alerting", True),
        ("ROI Projection ชัดเจน", True),
    ],
    "Machine": [
        ("CI/CD Pipeline พร้อมใช้งาน", True),
        ("Monitoring และ Alerting Setup", True),
        ("Auto-scaling Configuration", True),
        ("Disaster Recovery Plan", False),
        ("Development Environment ครบ", True),
        ("Security Tools (SAST/DAST)", False),
    ],
    "Material": [
        ("Source Code อยู่ใน Version Control", True),
        ("Documentation ครบถ้วน", False),
        ("Test Coverage > 80%", False),
        ("API Specifications (OpenAPI)", True),
        ("Data Migration Plan", True),
        ("Third-party Dependencies Audit", False),
    ],
    "Management": [
        ("Project Plan และ Timeline", True),
        ("Risk Register", False),
        ("Communication Plan", True),
        ("Change Management Process", True),
        ("Sprint Retrospective ทุก Sprint", True),
        ("Stakeholder Reporting", True),
    ],
}

# แสดง Checklist
print("5M Readiness Checklist")
print("=" * 50)

total_items = 0
total_ready = 0

for category, items in checklist.items():
    ready = sum(1 for _, status in items if status)
    total = len(items)
    total_items += total
    total_ready += ready
    pct = ready / total * 100

    print(f"\n[{category}] {ready}/{total} ({pct:.0f}%)")
    for item, status in items:
        mark = "v" if status else "x"
        print(f"  [{mark}] {item}")

overall = total_ready / total_items * 100
print(f"\nOverall Readiness: {total_ready}/{total_items} ({overall:.0f}%)")
print(f"Status: {'READY' if overall >= 80 else 'NOT READY'}")

5M คืออะไร

หลักการบริหาร 5 ปัจจัยหลัก Man (คน) Money (เงิน) Machine (เครื่องจักร/เทคโนโลยี) Material (วัตถุดิบ/ทรัพยากร) Management (การจัดการ) ใช้วิเคราะห์และปรับปรุงประสิทธิภาพองค์กร

สรุป

หลักการ 5M (Man, Money, Machine, Material, Management) เป็นกรอบแนวคิดที่ใช้ได้กับทุกองค์กร รวมถึง IT Projects ใช้ร่วมกับ Fishbone Diagram วิเคราะห์สาเหตุปัญหา ใช้ Checklist ประเมินความพร้อมก่อนเริ่มโครงการ ใช้ Dashboard ติดตามคะแนนแต่ละปัจจัย สิ่งสำคัญคือทั้ง 5 ปัจจัยเชื่อมโยงกัน ต้องพัฒนาไปพร้อมกัน