FDE のメトリクスと KPI — 成果を数字で語る

# app/models/fde_engagement.rb
class FdeEngagement < ApplicationRecord
  belongs_to :customer
  belongs_to :fde, class_name: "User"
 
  # TTV の計算
  def time_to_value_days
    return nil unless value_realized_at
 
    (value_realized_at.to_date - contract_signed_at.to_date).to_i
  end
 
  # 業界ベンチマークとの比較
  def ttv_reduction_percentage
    return nil unless time_to_value_days
 
    baseline = industry_baseline_days
    ((baseline - time_to_value_days).to_f / baseline * 100).round(1)
  end
 
  # セグメント別のベースライン（日数）
  def industry_baseline_days
    case customer.segment
    when "enterprise" then 120
    when "mid_market" then 60
    when "startup" then 30
    else 90
    end
  end
 
  scope :with_realized_value, -> { where.not(value_realized_at: nil) }
 
  scope :by_fde, ->(fde_id) { where(fde_id: fde_id) }
end

# app/services/pilot_conversion_analyzer.rb
class PilotConversionAnalyzer
  def initialize(period:)
    @period = period
  end
 
  def compare_conversion_rates
    {
      with_fde: calculate_rate(fde_assisted: true),
      without_fde: calculate_rate(fde_assisted: false),
      lift: conversion_lift
    }
  end
 
  private
 
  def calculate_rate(fde_assisted:)
    pilots = Pilot.where(started_at: @period, fde_assisted: fde_assisted)
    total = pilots.count
    return 0.0 if total.zero?
 
    (pilots.where(status: "converted").count.to_f / total * 100).round(1)
  end
 
  def conversion_lift
    with_rate = calculate_rate(fde_assisted: true)
    without_rate = calculate_rate(fde_assisted: false)
    return 0.0 if without_rate.zero?
 
    ((with_rate - without_rate) / without_rate * 100).round(1)
  end
end

# app/models/usage_spike_detector.rb
class UsageSpikeDetector
  SPIKE_THRESHOLD = 1.5 # 50%増で「スパイク」と判定
 
  def initialize(customer:, engagement:)
    @customer = customer
    @engagement = engagement
  end
 
  def analyze
    before = avg_usage(@engagement.started_at - 30.days, @engagement.started_at)
    after = avg_usage(@engagement.started_at, @engagement.started_at + 30.days)
 
    {
      before_avg: before,
      after_avg: after,
      growth_rate: before.zero? ? 0.0 : ((after - before) / before * 100).round(1),
      spike_detected: after > before * SPIKE_THRESHOLD
    }
  end
 
  private
 
  def avg_usage(from, to)
    UsageRecord.where(customer: @customer, recorded_at: from..to)
               .average(:api_calls_count)&.to_f || 0.0
  end
end

# app/services/time_allocation_tracker.rb
class TimeAllocationTracker
  CATEGORIES = %w[pre_sales post_sales internal product_feedback].freeze
 
  def initialize(fde:, period:)
    @fde = fde
    @period = period
  end
 
  def summary
    entries = TimeEntry.where(user: @fde, date: @period)
    total = entries.sum(:hours)
    return {} if total.zero?
 
    CATEGORIES.to_h do |cat|
      hours = entries.where(category: cat).sum(:hours)
      [cat, { hours: hours, percentage: (hours / total * 100).round(1) }]
    end
  end
end

# app/models/developer_onboarding.rb
class DeveloperOnboarding < ApplicationRecord
  belongs_to :developer
  belongs_to :api_product
 
  scope :recent, -> { where(signup_at: 30.days.ago..) }
 
  def ttfc_minutes
    return nil unless first_successful_call_at
 
    ((first_successful_call_at - signup_at) / 60.0).round(1)
  end
 
  def ttfc_grade
    case ttfc_minutes
    when nil then "N/A"
    when 0..5 then "excellent"
    when 6..15 then "good"
    when 16..30 then "needs_improvement"
    else "critical"
    end
  end
end

# app/services/dxi_impact_calculator.rb
class DxiImpactCalculator
  MINUTES_SAVED_PER_POINT = 13 # 1 DXI ポイントあたり週13分節約
 
  def initialize(team_size:, dxi_improvement:, hourly_rate: 80)
    @team_size = team_size
    @dxi_improvement = dxi_improvement
    @hourly_rate = hourly_rate
  end
 
  def weekly_hours_saved
    (@team_size * MINUTES_SAVED_PER_POINT * @dxi_improvement / 60.0).round(1)
  end
 
  def annual_savings_usd
    (weekly_hours_saved * 52 * @hourly_rate).round(0)
  end
end
 
# DxiImpactCalculator.new(team_size: 50, dxi_improvement: 5).annual_savings_usd
# => 225_333  （年間約$225K のコスト削減効果）

# app/models/fde_kpi_snapshot.rb
class FdeKpiSnapshot < ApplicationRecord
  belongs_to :fde, class_name: "User"
 
  # 月次スナップショットを生成
  def self.generate_monthly(fde:, month:)
    period = month.all_month
    engagements = FdeEngagement.by_fde(fde.id).where(started_at: period)
 
    create!(
      fde: fde,
      period_start: period.first, period_end: period.last,
      avg_ttv_days: avg_ttv(engagements),
      pilot_conversion_rate: PilotConversionAnalyzer.new(period: period)
                               .compare_conversion_rates[:with_fde],
      expansion_revenue_usd: expansion(fde, period),
      nps_score: nps(fde, period),
      integrations_completed: Integration.where(fde_id: fde.id,
                                completed_at: period, status: "success").count,
      go_lives: Deployment.where(fde_id: fde.id,
                  went_live_at: period, environment: "production").count,
      arr_per_fde: Customer.where(assigned_fde_id: fde.id, status: "active")
                           .sum(:arr_usd)
    )
  end
 
  class << self
    private
 
    def avg_ttv(engagements)
      vals = engagements.with_realized_value.filter_map(&:time_to_value_days)
      vals.empty? ? nil : (vals.sum.to_f / vals.size).round(1)
    end
 
    def expansion(fde, period)
      Contract.where(fde_attributed: fde.id, signed_at: period,
                     contract_type: "expansion").sum(:annual_value_usd)
    end
 
    def nps(fde, period)
      scores = NpsSurvey.where(fde_id: fde.id, submitted_at: period).pluck(:score)
      return nil if scores.empty?
 
      promoters = scores.count { |s| s >= 9 }
      detractors = scores.count { |s| s <= 6 }
      ((promoters - detractors).to_f / scores.size * 100).round(0)
    end
  end
end

# app/controllers/fde/dashboards_controller.rb
module Fde
  class DashboardsController < ApplicationController
    before_action :require_fde_role
 
    def show
      @fde = current_user
      @snapshots = FdeKpiSnapshot.where(fde: @fde)
                                  .order(period_start: :desc).limit(12)
      @current = @snapshots.first
      @trends = build_trends(@snapshots.reverse)
    end
 
    private
 
    def build_trends(snapshots)
      %i[avg_ttv_days pilot_conversion_rate arr_per_fde integrations_completed]
        .to_h { |col| [col, snapshots.to_h { |s| [s.period_start.strftime("%Y-%m"), s.send(col)] }] }
    end
 
    def require_fde_role
      redirect_to root_path, alert: "アクセス権限がありません" unless current_user.role == "fde"
    end
  end
end

<%# app/views/fde/dashboards/show.html.erb（抜粋） %>
<div class="grid grid-cols-2 gap-4">
  <div class="card">
    <h3>TTV 推移（日数）</h3>
    <%= line_chart @trends[:avg_ttv_days], colors: ["#d4a050"] %>
  </div>
  <div class="card">
    <h3>Pilot 転換率（%）</h3>
    <%= area_chart @trends[:pilot_conversion_rate], colors: ["#6cb6ff"] %>
  </div>
  <div class="card">
    <h3>ARR per FDE（USD）</h3>
    <%= column_chart @trends[:arr_per_fde], colors: ["#50c878"], prefix: "$" %>
  </div>
  <div class="card">
    <h3>インテグレーション完了数</h3>
    <%= bar_chart @trends[:integrations_completed], colors: ["#d4a050"] %>
  </div>
</div>

# config/initializers/quicksight.rb
module QuicksightHelper
  def self.generate_embed_url(dashboard_id:, user_arn:)
    client = Aws::QuickSight::Client.new(region: "ap-northeast-1")
    client.generate_embed_url_for_registered_user(
      aws_account_id: ENV.fetch("AWS_ACCOUNT_ID"),
      session_lifetime_in_minutes: 600,
      user_arn: user_arn,
      experience_configuration: { dashboard: { initial_dashboard_id: dashboard_id } }
    ).embed_url
  end
end

# app/models/concerns/kpi_classifiable.rb
module KpiClassifiable
  extend ActiveSupport::Concern
 
  LEADING  = %w[ttfc usage_growth_rate integrations_in_progress pilot_starts].freeze
  LAGGING  = %w[arr_per_fde pilot_conversion_rate expansion_revenue nps_score].freeze
 
  def indicator_type
    return :leading if LEADING.include?(metric_name)
    return :lagging if LAGGING.include?(metric_name)
 
    :unknown
  end
end

# app/models/engagement_milestone.rb
class EngagementMilestone < ApplicationRecord
  belongs_to :fde_engagement
 
  scope :first_outcome, -> { where(milestone_type: "first_outcome") }
  scope :overdue, -> { where("target_date < ? AND completed_at IS NULL", Date.current) }
 
  # 90日ルールの検証
  def self.validate_90_day_rule(engagement)
    first = engagement.milestones.first_outcome.first
    return { valid: false, reason: "First Outcome が未設定" } unless first
 
    days = (first.target_date - engagement.started_at.to_date).to_i
    days > 90 ? { valid: false, reason: "#{days}日目に設定（90日超過）" } : { valid: true, target_day: days }
  end
 
  def status
    return "completed" if completed_at
    return "overdue" if target_date < Date.current
    return "at_risk" if (target_date - Date.current).to_i <= 7
 
    "on_track"
  end
end