13. Desglose Completo de Costos: Framework 3-Phase para Presupuestos Realistas

🎯 Lo Que Aprenderás

Al completar esta lección, serás capaz de:

1. Aplicar el Framework 3-Phase de costos (Implementation, Operational, Hidden) para presupuestos completos y realistas
2. Calcular costos de datos con precisión - el costo oculto #1 que representa 20-40% del presupuesto total
3. Decidir build vs buy vs partner usando análisis de costos comparativo con TCO (Total Cost of Ownership)
4. Presupuestar infraestructura y tools incluyendo cloud, APIs, monitoring y integration costs
5. Usar calculadoras específicas por tipo de proyecto (chatbot, lead scoring, forecasting, etc.)

Tiempo estimado: 15 minutos Nivel: Intermedio Prerequisitos: Lección 12 (Business Case 101)

---

📋 Prerequisitos

Lo que necesitas saber:

• Los 3 costos ocultos principales (Lección 12)
• ROI básico y payback period
• Conceptos de cloud computing (básico)

Lo que NO necesitas:

• Expertise en pricing de vendors específicos
• Experiencia negociando contratos enterprise
• Background técnico profundo

---

🚀 Introducción

El Email que Todo CFO Odia

Marzo 2023 - Series B Startup:

De: CTO
Para: CFO
Asunto: Need Additional Budget - ML Project

Sarah,

Necesitamos $85K adicionales para el proyecto de ML que aprobaste.

Issues que no anticipamos:
- Data cleanup más complejo: +$35K
- APIs más caros que estimado: +$25K
- Need consultant extra: +$25K

¿Podemos aprobar?

- Tom

Respuesta del CFO (13 minutos después):

Tom,

Esto es exactamente lo que quería evitar.

Aprobé $180K hace 3 meses basado en tu business case.
Ahora es $265K (+47%).

Pregunta simple: ¿Hay MÁS sorpresas coming?

No aprobaré más budget hasta que:
1. Me muestres breakdown COMPLETO de costos
2. Expliques por qué fallamos en estimar correctamente
3. Me des confianza que $265K es el número FINAL

Este tipo de budget creep destruye credibilidad.
Siguiente vez, haz el homework ANTES de pedir aprobación.

- Sarah

Resultado:

• Trust dañado
• Proyecto pausado 6 semanas
• CTO tuvo que hacer audit completo de costos
• Future business cases bajo escrutinio 10x mayor

---

El Framework que Previene Budget Creep

La solución: Framework 3-Phase de Costos

framework_3_phase = {
    'phase_1_implementation': {
        'descripcion': 'One-time costs para poner sistema en producción',
        'categorias': [
            'Desarrollo/Consultora',
            'Datos (prep, cleanup, labeling)',
            'Infraestructura & tools',
            'Integration con sistemas existentes',
            'Testing & QA'
        ],
        'timeline': '2-6 meses típicamente',
        'percentage_total': '40-50% del total Year 1'
    },

    'phase_2_operational': {
        'descripcion': 'Recurring costs para mantener sistema running',
        'categorias': [
            'Cloud compute & storage',
            'APIs de terceros',
            'Licenses de software',
            'Personal (mantenimiento, monitoring)',
            'Retraining de modelos'
        ],
        'timeline': 'Ongoing cada año',
        'percentage_total': '30-40% del total Year 1'
    },

    'phase_3_hidden': {
        'descripcion': 'Costos que casi siempre se olvidan',
        'categorias': [
            'Change management & training',
            'Productivity loss durante adoption',
            'Deuda técnica (refactoring, integration)',
            'Contingencia (15-25% buffer)'
        ],
        'timeline': 'Mayormente en primeros 3-6 meses',
        'percentage_total': '20-30% del total Year 1'
    },

    'formula_rapida': '''
        Budget REAL = Implementation + Operational + Hidden

        Si calculaste solo Implementation:
        Budget REAL = Implementation × 2.0-2.5

        Ejemplo:
        Implementation calculado: $200K
        Budget REAL necesario: $400K-500K
    '''
}

En esta lección aplicaremos este framework a escenarios reales con números específicos.

---

📚 Conceptos Fundamentales

FASE 1: Costos de Implementación - Breakdown Detallado

A. Desarrollo/Consultora: Build vs Buy vs Partner

El Dilema más Común:

opcion_1_build_interno = {
    'descripcion': 'Tu equipo construye la solución',

    'costos_directos': {
        'salaries': {
            'data_scientist_senior': {
                'salary_annual': 145000,
                'benefits_overhead': 30000,  # 20% loaded cost
                'tiempo_dedicado': '5 meses',
                'costo': 72917  # (145K+30K)/12*5
            },
            'ml_engineer': {
                'salary_annual': 125000,
                'overhead': 25000,
                'tiempo': '4 meses',
                'costo': 50000
            },
            'backend_engineer': {
                'salary_annual': 115000,
                'overhead': 23000,
                'tiempo': '3 meses',
                'costo': 34500
            },
            'product_manager': {
                'salary_annual': 130000,
                'overhead': 26000,
                'tiempo': '4 meses part-time (40%)',
                'costo': 20800
            }
        },
        'total_salaries': 178217
    },

    'costos_ocultos': {
        'opportunity_cost': {
            'descripcion': 'Estos recursos NO trabajan en otros proyectos',
            'features_delayed': 2,
            'estimated_value': 60000,
            'nota': 'CFOs sofisticados cuentan esto'
        },
        'tools_infrastructure': {
            'ml_experiment_tracking': 8000,  # MLflow, Weights & Biases
            'cloud_training': 12000,
            'monitoring_tools': 6000,
            'total': 26000
        },
        'knowledge_gaps': {
            'descripcion': 'Si tu equipo no tiene expertise específico',
            'training_courses': 8000,
            'consultant_advisory': 15000,  # Part-time expert guidance
            'total': 23000
        }
    },

    'total_build': 287217,
    'timeline': '5-7 meses',

    'pros': [
        'IP ownership completo',
        'Customization total',
        'No vendor lock-in',
        'Team aprende skills valiosos'
    ],

    'cons': [
        'Más caro upfront',
        'Timeline más largo',
        'Risk: Si personas se van, pierdes knowledge',
        'Distracts from core product'
    ],

    'cuando_tiene_sentido': [
        'Problema único/propietario',
        'Tienes ML talent disponible',
        'Timeline no es crítico',
        'Competitive advantage si in-house'
    ]
}

opcion_2_buy_saas = {
    'descripcion': 'Comprar plataforma SaaS existente',

    'ejemplo_hubspot_sales_ai': {
        'setup_fee': 15000,  # Implementation, data migration
        'annual_license': 36000,  # $3K/mes para 10 users
        'year1_total': 51000,

        'costos_adicionales': {
            'data_preparation': 18000,  # Still need clean data
            'integration_custom': 25000,  # Connect con tus sistemas
            'training': 12000,  # Team needs to learn tool
            'ongoing_admin': 15000,  # Part-time admin
            'total_adicional': 70000
        },

        'total_year1': 121000
    },

    'pros': [
        'Faster time to value (2-3 meses)',
        'Proven solution',
        'Support incluido',
        'Regular updates automáticos',
        'Menor risk técnico'
    ],

    'cons': [
        'Less customization',
        'Vendor lock-in',
        'Costos recurrentes perpetuos',
        'Data privacy concerns'
    ],

    'cuando_tiene_sentido': [
        'Problema común/standard',
        'Need results rápido',
        'No tienes ML expertise interno',
        'Budget limitado Year 1'
    ]
}

opcion_3_partner_consultora = {
    'descripcion': 'Consultora build custom solution para ti',

    'ejemplo_boutique_ml_firm': {
        'discovery_requirements': 20000,
        'data_preparation_support': 35000,
        'model_development': 85000,
        'integration_deployment': 45000,
        'training_documentation': 18000,
        'warranty_support_3meses': 12000,
        'total': 215000
    },

    'hidden_costs': {
        'internal_team_time': {
            'descripcion': 'Tu equipo still needs participar',
            'pm_time': '40% × 4 meses = $20K',
            'eng_time': '30% × 4 meses = $15K',
            'stakeholder_time': '10K',
            'total': 45000
        },
        'knowledge_transfer': {
            'descripcion': 'Si no documentan bien, quedas dependiente',
            'risk': 'Medio-Alto',
            'mitigation': 'Require detailed documentation + training'
        }
    },

    'total_real': 260000,
    'timeline': '3-5 meses',

    'pros': [
        'Expertise inmediato',
        'Custom fit a tu caso',
        'Transfer knowledge a tu equipo',
        'Fixed price (si negociado bien)'
    ],

    'cons': [
        'Caro',
        'Riesgo de quality variable',
        'Dependency durante proyecto',
        'Need vet consultora cuidadosamente'
    ],

    'cuando_tiene_sentido': [
        'Problema semi-custom',
        'Need expertise que no tienes',
        'Quieres IP ownership eventual',
        'Budget suficiente'
    ]
}

# COMPARACIÓN DIRECTA:
comparison = {
    'metric': {
        'build': 'Buy (SaaS)', 'partner'
    },
    'year1_cost': {
        'build': 287000,
        'buy': 121000,
        'partner': 260000
    },
    'year2_cost': {
        'build': 85000,  # Solo maintenance
        'buy': 121000,  # Mismo recurring
        'partner': 50000  # Menos mantenimiento
    },
    'timeline': {
        'build': '5-7 meses',
        'buy': '2-3 meses',
        'partner': '3-5 meses'
    },
    'risk': {
        'build': 'Alto',
        'buy': 'Bajo',
        'partner': 'Medio'
    },
    'customization': {
        'build': 'Total',
        'buy': 'Limitado',
        'partner': 'Alto'
    },

    # TCO 3 AÑOS:
    'tco_3_years': {
        'build': 457000,  # 287K + 85K + 85K
        'buy': 363000,   # 121K + 121K + 121K
        'partner': 360000  # 260K + 50K + 50K
    }
}

RECOMENDACIÓN FRAMEWORK:

Si tu problema es:
├─ Standard/común (lead scoring, chatbot, recommendations)
│  └─ Buy SaaS (cheapest, fastest)
│
├─ Semi-custom pero no core differentiator
│  └─ Partner (balance cost/speed/quality)
│
└─ Único, propietario, core competitive advantage
   └─ Build (most expensive pero ownership completo)

---

B. Datos: El Costo Oculto #1 - Calculadora Detallada

El costo que SIEMPRE se subestima:

class DataCostCalculator:
    """
    Calculadora de costos de datos con inputs específicos
    """

    def __init__(self):
        self.costs = {}

    def assess_data_complexity(self,
                               num_sources=1,
                               data_quality_score=0.8,  # 0-1
                               volume_gb=100,
                               has_apis=True,
                               needs_labeling=False):
        """
        Evalúa complejidad y estima costos
        """

        # PASO 1: Data Integration
        integration_cost = self._calc_integration(num_sources, has_apis)

        # PASO 2: Data Quality/Cleanup
        cleanup_cost = self._calc_cleanup(volume_gb, data_quality_score)

        # PASO 3: Labeling (si necesario)
        labeling_cost = self._calc_labeling(needs_labeling, volume_gb)

        # PASO 4: Enrichment (opcional)
        enrichment_cost = self._calc_enrichment()

        total = sum([
            integration_cost,
            cleanup_cost,
            labeling_cost,
            enrichment_cost
        ])

        return {
            'integration': integration_cost,
            'cleanup': cleanup_cost,
            'labeling': labeling_cost,
            'enrichment': enrichment_cost,
            'total_data_costs': total,
            'breakdown_display': self._format_output(
                integration_cost,
                cleanup_cost,
                labeling_cost,
                enrichment_cost,
                total
            )
        }

    def _calc_integration(self, num_sources, has_apis):
        """Costo de integrar múltiples fuentes de datos"""

        if has_apis:
            # Con APIs: Más fácil
            base_per_source = 3000
            complexity_multiplier = 1.0
        else:
            # Sin APIs: Legacy, manual export, custom connectors
            base_per_source = 8000
            complexity_multiplier = 1.5

        cost = base_per_source * num_sources * complexity_multiplier

        # Add overhead si >5 fuentes
        if num_sources > 5:
            overhead = (num_sources - 5) * 2000
            cost += overhead

        return int(cost)

    def _calc_cleanup(self, volume_gb, quality_score):
        """Costo de limpieza basado en volumen y calidad"""

        # Quality score: 1.0 = perfect, 0.0 = terrible
        quality_factor = (1.0 - quality_score) * 2  # Inversamente proporcional

        # Volume factor
        if volume_gb < 10:
            volume_factor = 1.0
        elif volume_gb < 100:
            volume_factor = 1.5
        elif volume_gb < 1000:
            volume_factor = 2.0
        else:
            volume_factor = 3.0

        base_cleanup_cost = 15000
        cost = base_cleanup_cost * quality_factor * volume_factor

        return int(cost)

    def _calc_labeling(self, needs_labeling, volume_gb):
        """Costo de labeling para supervised learning"""

        if not needs_labeling:
            return 0

        # Estimate records based on volume
        # Assuming avg 1KB per record
        estimated_records = volume_gb * 1024  # GB to MB

        # Labeling cost per record varies by complexity
        cost_per_label = 0.15  # $0.15 average (crowdsourcing)

        # Not all records need labeling, usually 20-40%
        labeling_percentage = 0.30

        records_to_label = estimated_records * labeling_percentage
        cost = records_to_label * cost_per_label

        return int(cost)

    def _calc_enrichment(self):
        """Costos de enriquecer data con fuentes externas"""

        # Este es opcional, return 0 si no aplica
        # Ejemplos: Weather data, demographic data, firmographics

        return 0  # Override si necesitas enrichment

    def _format_output(self, integration, cleanup, labeling, enrichment, total):
        return f'''
╔══════════════════════════════════════════════════════
║ DATA COSTS BREAKDOWN
╚══════════════════════════════════════════════════════

Integration (múltiples fuentes):     ${integration:,}
Data quality/cleanup:                 ${cleanup:,}
Labeling (si supervised learning):    ${labeling:,}
Enrichment (data externa):            ${enrichment:,}
───────────────────────────────────────────────────────
TOTAL DATA COSTS:                     ${total:,}

⚠️ REGLA DE ORO:
Data costs típicamente = 20-40% del total implementation
Si tu implementation budget es $200K, data debería ser $40K-80K

Este cálculo: {(total/200000)*100:.0f}% del budget
        '''

# EJEMPLO DE USO:
calc = DataCostCalculator()

# Escenario 1: Proyecto simple
simple = calc.assess_data_complexity(
    num_sources=2,
    data_quality_score=0.85,  # Good quality
    volume_gb=50,
    has_apis=True,
    needs_labeling=False
)
print("ESCENARIO SIMPLE (CRM + Web Analytics):")
print(simple['breakdown_display'])

# Escenario 2: Proyecto complejo
complex = calc.assess_data_complexity(
    num_sources=8,
    data_quality_score=0.55,  # Poor quality
    volume_gb=500,
    has_apis=False,  # Legacy systems
    needs_labeling=True
)
print("\nESCENARIO COMPLEJO (Multiple legacy systems):")
print(complex['breakdown_display'])

Output esperado:

ESCENARIO SIMPLE (CRM + Web Analytics):

╔══════════════════════════════════════════════════════
║ DATA COSTS BREAKDOWN
╚══════════════════════════════════════════════════════

Integration (múltiples fuentes):     $6,000
Data quality/cleanup:                 $6,750
Labeling (si supervised learning):    $0
Enrichment (data externa):            $0
───────────────────────────────────────────────────────
TOTAL DATA COSTS:                     $12,750

⚠️ Este cálculo: 6% del budget ($200K base)


ESCENARIO COMPLEJO (Multiple legacy systems):

╔══════════════════════════════════════════════════════
║ DATA COSTS BREAKDOWN
╚══════════════════════════════════════════════════════

Integration (múltiples fuentes):     $102,000
Data quality/cleanup:                 $54,000
Labeling (si supervised learning):    $46,080
Enrichment (data externa):            $0
───────────────────────────────────────────────────────
TOTAL DATA COSTS:                     $202,080

⚠️ Este cálculo: 101% del budget
ALERT: Data costs EXCEDEN implementation budget!

Red Flags de Data Costs:

red_flags_datos = {
    'señales_alerta': {
        'flag_1': {
            'sintoma': '"Los datos ya existen, costo cero"',
            'realidad': 'Existen pero no están listos para ML',
            'costo_escondido': '$20K-60K cleanup + integration'
        },
        'flag_2': {
            'sintoma': '"Solo exportamos del CRM"',
            'realidad': 'CRM data quality typically <70%',
            'costo_escondido': '$15K-40K deduplication + standardization'
        },
        'flag_3': {
            'sintoma': '"No need labeling, usaremos unsupervised"',
            'realidad': 'Unsupervised funciona solo para use cases específicos',
            'riesgo': 'Descubres después que SÍ necesitas labels → +$30K-80K'
        },
        'flag_4': {
            'sintoma': 'Múltiples sistemas legacy sin APIs',
            'realidad': 'Need custom connectors o middleware',
            'costo_escondido': '$50K-150K integration'
        },
        'flag_5': {
            'sintoma': 'Nadie sabe dónde están ciertos datos',
            'realidad': 'Data discovery y documentation necesario',
            'costo_escondido': '$10K-30K data archeology'
        }
    },

    'checklist_antes_de_budgetear': [
        '✅ ¿Dónde están los datos? (lista TODOS los sistemas)',
        '✅ Sample 100 records: ¿Qué % usable as-is?',
        '✅ ¿Data quality score real? (run profiling)',
        '✅ ¿Tienen APIs o export manual?',
        '✅ ¿Etiquetados para ML?',
        '✅ ¿Formato consistente cross-systems?',
        '✅ ¿PII/sensitive data → compliance issues?',
        '✅ ¿Historical data suficiente? (min 6-12 meses)'
    ]
}

---

🛠️ Implementación Práctica

Template: Calculadora de Costos por Tipo de Proyecto

class ProjectCostCalculator:
    """
    Templates de costos para proyectos comunes de IA
    """

    def chatbot_customer_service(self, team_size=30, ticket_volume_monthly=10000):
        """
        Costos para chatbot de customer service
        """

        # PHASE 1: Implementation
        implementation = {
            'plataforma': {
                'options': {
                    'zendesk_ai': 25000,  # Year 1 setup + license
                    'intercom_fin': 35000,
                    'custom_build': 180000
                },
                'selected': 'intercom_fin',
                'cost': 35000
            },

            'data_prep': {
                'historical_tickets': ticket_volume_monthly * 6,  # 6 months history
                'labeling_cost': ticket_volume_monthly * 6 * 0.05,  # $0.05 per ticket
                'categorization': 12000,
                'total': int(ticket_volume_monthly * 6 * 0.05) + 12000
            },

            'integration': {
                'zendesk_integration': 15000,
                'crm_integration': 12000,
                'knowledge_base_setup': 18000,
                'total': 45000
            },

            'testing': 15000,

            'subtotal': lambda: (35000 +
                               int(ticket_volume_monthly * 6 * 0.05) + 12000 +
                               45000 +
                               15000)
        }

        # PHASE 2: Operational Year 1
        operational = {
            'platform_license': 35000,  # Annual
            'api_costs': {
                'gpt4_tokens': ticket_volume_monthly * 12 * 0.15,  # $0.15 per response
                'total': int(ticket_volume_monthly * 12 * 0.15)
            },
            'monitoring': 8000,
            'maintenance': 25000,  # Part-time engineer

            'subtotal': lambda: (35000 +
                               int(ticket_volume_monthly * 12 * 0.15) +
                               8000 +
                               25000)
        }

        # PHASE 3: Hidden Costs
        hidden = {
            'training': {
                'agents_training': team_size * 8 * 50,  # 8hrs × $50/hr
                'ongoing_enablement': 15000,
                'total': team_size * 8 * 50 + 15000
            },
            'productivity_loss': {
                'description': '20% less productive for 2 months during adoption',
                'team_avg_salary': 45000,
                'loss_percentage': 0.20,
                'duration_months': 2,
                'cost': int(team_size * (45000/12) * 2 * 0.20)
            },
            'contingency': lambda impl, oper: int((impl + oper) * 0.15),

            'subtotal': lambda impl, oper: (
                team_size * 8 * 50 + 15000 +
                int(team_size * (45000/12) * 2 * 0.20) +
                int((impl + oper) * 0.15)
            )
        }

        # Calculate totals
        impl_total = implementation['subtotal']()
        oper_total = operational['subtotal']()
        hidden_total = hidden['subtotal'](impl_total, oper_total)

        total_year1 = impl_total + oper_total + hidden_total

        return {
            'project_type': 'Chatbot Customer Service',
            'inputs': {
                'team_size': team_size,
                'ticket_volume_monthly': ticket_volume_monthly
            },
            'phase_1_implementation': impl_total,
            'phase_2_operational': oper_total,
            'phase_3_hidden': hidden_total,
            'total_year1': total_year1,
            'year2_recurring': oper_total,

            'summary': f'''
╔════════════════════════════════════════════════════════
║ CHATBOT CUSTOMER SERVICE - COST BREAKDOWN
╚════════════════════════════════════════════════════════

INPUTS:
  Team size:                {team_size} agents
  Monthly ticket volume:    {ticket_volume_monthly:,}

YEAR 1 COSTS:

Phase 1 - Implementation (One-time):
  Platform setup:           ${implementation['plataforma']['cost']:,}
  Data preparation:         ${implementation['data_prep']['total']:,}
  Integration:              ${implementation['integration']['total']:,}
  Testing:                  ${implementation['testing']:,}
  ────────────────────────────────────────
  Subtotal:                 ${impl_total:,}

Phase 2 - Operational (Recurring):
  Platform license:         ${operational['platform_license']:,}
  API costs (GPT-4):        ${operational['api_costs']['total']:,}
  Monitoring:               ${operational['monitoring']:,}
  Maintenance:              ${operational['maintenance']:,}
  ────────────────────────────────────────
  Subtotal:                 ${oper_total:,}

Phase 3 - Hidden Costs:
  Training:                 ${hidden['training']['total']:,}
  Productivity loss:        ${int(team_size * (45000/12) * 2 * 0.20):,}
  Contingency (15%):        ${int((impl_total + oper_total) * 0.15):,}
  ────────────────────────────────────────
  Subtotal:                 ${hidden_total:,}

════════════════════════════════════════════════════════
TOTAL YEAR 1:               ${total_year1:,}
YEAR 2+ (Recurring):        ${oper_total:,}
════════════════════════════════════════════════════════

⚠️ IMPORTANT NOTES:
• API costs escalan con volume - monitor closely
• Year 2+ = operational only (no implementation)
• Contingency cover data quality issues, delays
            '''
        }

# EJEMPLO DE USO:
calc = ProjectCostCalculator()

# Escenario pequeño
small_team = calc.chatbot_customer_service(team_size=15, ticket_volume_monthly=5000)
print(small_team['summary'])

# Escenario grande
large_team = calc.chatbot_customer_service(team_size=50, ticket_volume_monthly=25000)
print(large_team['summary'])

---

⚠️ Errores Comunes y Soluciones

Error #1: Olvidar Costos Recurrentes de Year 2+

Problema:

Business case muestra: "ROI 800% en Year 1!"

Year 2:
CFO: "¿Por qué necesitamos $180K más?"
PM: "Es para mantener el sistema..."
CFO: "Eso no estaba en tu business case"

Solución:

multi_year_budget_template = {
    'year_1': {
        'implementation_onetime': 280000,
        'operational_partial': 95000,  # 8 months post-launch
        'hidden_costs': 120000,
        'total': 495000
    },

    'year_2': {
        'implementation': 0,  # Ya hecho
        'operational_full': 142500,  # 12 months full
        'improvements': 35000,  # Enhancements
        'total': 177500
    },

    'year_3': {
        'operational': 142500,
        'improvements': 25000,
        'total': 167500
    },

    # TOTAL COMMITMENT 3 YEARS:
    'tco_3_years': 840000,

    'presentacion': '''
        BUDGET REQUEST - 3 YEAR VIEW

        Year 1:  $495K (includes one-time implementation)
        Year 2:  $178K (operational only)
        Year 3:  $168K (operational)
        ─────────────────────────────────
        3-Year TCO: $840K

        This is the FULL picture.
        Year 2-3 costs are required to maintain value.
    '''
}

BEST PRACTICE:

Always show 3-year TCO in business case CFOs appreciate honesty upfront más que surprises later

---

Error #2: Under-budgeting Change Management

Problema:

Budget aprobado: $200K
Spend en tech: $200K
Change management: $0

Resultado:
- Team no usa sistema
- Adoption rate: 23%
- ROI: 0% (porque nadie lo usa)

Solución:

change_mgmt_formula = {
    'regla_basica': '''
        Change Mgmt Budget = 25-40% de Implementation Budget

        Si implementation es $200K:
        Change mgmt debería ser $50K-80K
    ''',

    'breakdown_detallado': {
        'training_formal': {
            'initial_training': 'Team size × 8 horas × $50/hr loaded',
            'ejemplo': '40 personas × 8hrs × $50 = $16K'
        },
        'ongoing_support': {
            'office_hours': '$3K-5K/mes × 3 meses',
            'documentation': '$8K-12K',
            'total': '$20K-30K'
        },
        'productivity_loss': {
            'formula': 'Team size × Avg salary × 30% loss × 2 meses',
            'ejemplo': '40 × $80K × 30% × (2/12) = $160K',
            'nota': '⚠️ Este es HUGE y nadie lo budgetea'
        },
        'executive_sponsorship': {
            'description': 'Senior leader time para drive adoption',
            'time_commitment': '10% durante 4 meses',
            'value': 'Intangible pero crítico'
        }
    },

    'total_ejemplo': {
        'training': 16000,
        'ongoing': 25000,
        'productivity_loss': 160000,
        'contingency': 30000,
        'total': 231000,
        'note': 'Para proyecto de $200K, change mgmt es $231K (1.15x!)'
    }
}

---

✅ Checkpoint de Comprensión

1. ¿Cuál es el Framework 3-Phase y qué % representa cada fase del budget total?

Respuesta:

Framework 3-Phase:

1. Implementation (40-50% del Year 1 total)

   • Desarrollo/Consultora
   • Preparación de datos
   • Infraestructura & tools
   • Integration
   • One-time costs

2. Operational (30-40% del Year 1 total)

   • Cloud compute & storage
   • APIs recurrentes
   • Licenses
   • Personal (maintenance)
   • Retraining de modelos
   • Ongoing costs

3. Hidden (20-30% del Year 1 total)

   • Change management & training
   • Productivity loss
   • Deuda técnica
   • Contingencia (15-25%)

Total: 100% del budget realista

Fórmula rápida: Si calculaste solo Implementation = $200K Budget REAL = $200K × 2.0-2.5 = $400K-500K

2. ¿Cuándo deberías hacer Build vs Buy vs Partner?

Respuesta:

BUY (SaaS):

• ✅ Problema standard/común (chatbot, lead scoring)
• ✅ Need results rápido (2-3 meses)
• ✅ Budget limitado Year 1
• ✅ No tienes ML expertise interno
• 💰 Cheapest TCO 3 años usualmente

PARTNER (Consultora):

• ✅ Problema semi-custom
• ✅ Need expertise específico
• ✅ Quieres IP ownership eventual
• ✅ Budget moderado-alto
• 💰 Balance entre cost/speed/quality

BUILD (In-house):

• ✅ Problema único/propietario
• ✅ Core competitive differentiator
• ✅ Tienes ML talent disponible
• ✅ Timeline no crítico (5-7 meses)
• 💰 Most expensive upfront pero ownership completo

TCO 3 años (ejemplo):

• Build: $457K
• Buy: $363K
• Partner: $360K

3. ¿Por qué costos de datos típicamente son 20-40% del budget y cómo calcularlos?

Respuesta:

Componentes de Data Costs:

1. Integration (30-40% of data costs)

   • Múltiples fuentes de datos
   • Legacy systems sin APIs
   • Custom connectors/middleware
   • Costo: $3K-8K por fuente

2. Cleanup/Quality (40-50% of data costs)

   • Deduplication
   • Standardization
   • Missing values
   • Format consistency
   • Costo basado en volume + quality score

3. Labeling (0-30% of data costs)

   • Supervised learning requiere labels
   • Crowdsourcing: $0.05-0.50 per label
   • Expert labeling: $50-200/hora
   • Típicamente 20-40% de records need labeling

4. Enrichment (0-20% of data costs)

   • External data sources
   • Weather, demographics, firmographics
   • APIs de terceros

Red Flags:

• ❌ "Datos ya existen, costo cero"
• ❌ "Solo exportamos del CRM"
• ❌ Múltiples legacy systems
• ❌ Nadie sabe data quality score

Si ves estos flags: Budget 30-50% para datos, no 10-20%

---

🎯 Puntos Clave para Recordar

1. Framework 3-Phase es tu salvavidas:

   • Implementation (40-50%)
   • Operational (30-40%)
   • Hidden (20-30%)
   • Total = 2.0-2.5x tu cálculo inicial

2. Build vs Buy vs Partner:

   • Buy para standard problems (fastest, cheapest)
   • Partner para semi-custom (balanced)
   • Build para core differentiators (most expensive)

3. Data costs son 20-40% del total:

   • Integration + Cleanup + Labeling + Enrichment
   • NUNCA asumas "costo cero" para datos
   • Run data audit ANTES de budgetear

4. Change Management = 25-40% de Implementation:

   • Training formal
   • Ongoing support
   • Productivity loss (el más grande)
   • NO optional, es CRÍTICO

5. Always show 3-year TCO:

   • Year 1: Implementation + Operational + Hidden
   • Year 2-3: Solo Operational
   • CFOs aprecian honesty upfront

6. Contingencia no es padding:

   • 15-25% es REALISTA
   • 60% de proyectos overrun timeline
   • 30% necesitan más budget que estimado

---

🔜 Próximos Pasos

En la siguiente lección aprenderás:

Lección 14: Beneficios y Payback Period

Ahora que sabes calcular costos COMPLETOS, la próxima lección cubre:

• Framework de beneficios (Hard savings, Soft savings, Strategic)
• Calcular ahorro vs revenue incremental
• Payback period realista (no "inmediato")
• Casos con números reales y validation methods
• Cómo hacer assumptions defensibles

Por qué es importante:

Saber costos es solo 50% del business case. La otra mitad es demostrar beneficios de manera creíble que el CFO no pueda cuestionar.

---

Actualizado: Octubre 2025 Tiempo de lectura: 15 minutos Nivel: Intermedio

---

Metadata del Curso:

module: 4
lesson: 13
title: "Desglose Completo de Costos"
duration_minutes: 15
difficulty: intermediate
prerequisites: ["12-business-case-101"]
next_lesson: "14-beneficios-payback"
learning_objectives:
  - "Aplicar Framework 3-Phase de costos"
  - "Calcular costos de datos (20-40% del total)"
  - "Decidir build vs buy vs partner con TCO"
  - "Presupuestar infraestructura y tools"
  - "Usar calculadoras por tipo de proyecto"
tags: ["costos", "presupuesto", "roi", "tco", "business-case"]