FDE キャリアパス — ジュニアからリーダーシップへの道

# app/services/career_transition/swe_to_fde_evaluator.rb
module CareerTransition
  class SweToFdeEvaluator
    REQUIRED_SKILLS = {
      technical: %i[
        system_design api_integration
        debugging infrastructure
      ],
      customer_facing: %i[
        presentation stakeholder_management
        requirement_gathering escalation_handling
      ],
      business: %i[
        revenue_awareness timeline_management
        scoping documentation
      ]
    }.freeze
 
    def initialize(candidate)
      @candidate = candidate
    end
 
    def readiness_score
      scores = REQUIRED_SKILLS.map do |category, skills|
        weight = category_weight(category)
        skill_scores = skills.map { |s| @candidate.skill_level(s) }
        average = skill_scores.sum.to_f / skill_scores.size
        { category:, average:, weighted: average * weight }
      end
 
      {
        total: scores.sum { |s| s[:weighted] }.round(1),
        breakdown: scores,
        recommendation: recommend(scores)
      }
    end
 
    private
 
    def category_weight(category)
      case category
      when :technical       then 0.4
      when :customer_facing then 0.35
      when :business        then 0.25
      end
    end
 
    def recommend(scores)
      total = scores.sum { |s| s[:weighted] }
      if total >= 8.0
        "即戦力。FDE ポジションへの応募を推奨"
      elsif total >= 6.0
        "条件付き推奨。customer_facing スキルの強化が必要"
      else
        "準備期間が必要。SE またはテクニカルサポートで経験を積むことを推奨"
      end
    end
  end
end

# app/models/career_ladder.rb
class CareerLadder < ApplicationRecord
  has_many :levels, -> { order(:position) },
           class_name: "CareerLevel",
           dependent: :destroy
 
  validates :name, presence: true, uniqueness: true
 
  def level_for(position)
    levels.find_by(position:)
  end
end
 
# app/models/career_level.rb
class CareerLevel < ApplicationRecord
  belongs_to :career_ladder
  has_many :skill_requirements, dependent: :destroy
  has_many :skill_assessments, dependent: :destroy
 
  validates :name, :position, presence: true
  validates :position, uniqueness: { scope: :career_ladder_id }
 
  scope :at_or_below, ->(pos) { where(position: ..pos) }
 
  def next_level
    career_ladder.levels.find_by(position: position + 1)
  end
 
  def compensation_range
    {
      base: base_salary_min..base_salary_max,
      tc: total_comp_min..total_comp_max
    }
  end
end

# app/models/skill_assessment.rb
class SkillAssessment < ApplicationRecord
  belongs_to :user
  belongs_to :career_level
  belongs_to :skill_requirement
 
  validates :score, inclusion: { in: 1..5 }
  validates :assessed_at, presence: true
  validates :user_id, uniqueness: {
    scope: %i[career_level_id skill_requirement_id],
    message: "は同じスキル要件に対して1つの評価のみ"
  }
 
  enum :assessment_type, {
    self_assessment: 0,
    manager_review: 1,
    peer_review: 2,
    customer_feedback: 3
  }
 
  scope :recent, -> { where(assessed_at: 6.months.ago..) }
  scope :by_category, ->(cat) {
    joins(:skill_requirement).where(skill_requirements: { category: cat })
  }
end

# app/services/promotion_readiness.rb
class PromotionReadiness
  CATEGORY_WEIGHTS = {
    technical: 0.35,
    customer_facing: 0.30,
    business_impact: 0.20,
    leadership: 0.15
  }.freeze
 
  PROMOTION_THRESHOLD = 3.5
  STRONG_CANDIDATE_THRESHOLD = 4.0
 
  Result = Data.define(
    :ready, :score, :category_scores,
    :gaps, :strengths, :recommendation
  )
 
  def initialize(user, target_level)
    @user = user
    @target_level = target_level
    @assessments = user.skill_assessments
                       .where(career_level: target_level)
                       .recent
  end
 
  def evaluate
    scores = calculate_category_scores
    overall = weighted_score(scores)
    gaps = identify_gaps(scores)
    strengths = identify_strengths(scores)
 
    Result.new(
      ready: overall >= PROMOTION_THRESHOLD,
      score: overall.round(2),
      category_scores: scores,
      gaps:,
      strengths:,
      recommendation: build_recommendation(overall, gaps)
    )
  end
 
  private
 
  def calculate_category_scores
    CATEGORY_WEIGHTS.keys.each_with_object({}) do |category, hash|
      assessments = @assessments.by_category(category)
      hash[category] = if assessments.any?
                         assessments.average(:score).to_f.round(2)
                       else
                         0.0
                       end
    end
  end
 
  def weighted_score(scores)
    scores.sum { |category, score| score * CATEGORY_WEIGHTS[category] }
  end
 
  def identify_gaps(scores)
    scores.select { |_, score| score < 3.0 }
          .map { |category, score|
            {
              category:,
              current: score,
              target: 3.0,
              action: gap_action(category)
            }
          }
  end
 
  def identify_strengths(scores)
    scores.select { |_, score| score >= 4.0 }.keys
  end
 
  def gap_action(category)
    case category
    when :technical
      "複雑な顧客案件へのアサインを増やし、アーキテクチャ設計の経験を積む"
    when :customer_facing
      "C-suite とのミーティングでプレゼンターを務める機会を作る"
    when :business_impact
      "ARR 貢献を定量化するレポートを毎月作成する"
    when :leadership
      "L1 メンバーのメンタリングを開始し、技術ブログを月1本公開する"
    end
  end
 
  def build_recommendation(score, gaps)
    if score >= STRONG_CANDIDATE_THRESHOLD
      "強い昇格候補。次の評価サイクルでの昇格を推奨"
    elsif score >= PROMOTION_THRESHOLD
      "昇格可能。#{gaps.map { |g| g[:category] }.join('・')}の改善で確度が上がる"
    elsif score >= 2.5
      "6-12ヶ月後に再評価。重点改善領域: #{gaps.first&.dig(:category)}"
    else
      "現レベルでの経験蓄積が必要。1年後に再評価を推奨"
    end
  end
end

# FDE キャリアラダーの作成
ladder = CareerLadder.create!(name: "Forward Deployed Engineer")
 
senior_level = ladder.levels.create!(
  name: "L3 Senior FDE",
  position: 3,
  base_salary_min: 200_000,
  base_salary_max: 260_000,
  total_comp_min: 300_000,
  total_comp_max: 450_000
)
 
# スキル要件の登録
senior_level.skill_requirements.create!([
  { name: "アーキテクチャ設計", category: :technical, min_score: 4 },
  { name: "C-suite 対応", category: :customer_facing, min_score: 3 },
  { name: "ARR 貢献", category: :business_impact, min_score: 3 },
  { name: "メンタリング", category: :leadership, min_score: 3 }
])
 
# 昇格準備度の評価
result = PromotionReadiness.new(souta, senior_level).evaluate
result.ready          #=> false
result.score          #=> 3.12
result.gaps           #=> [{category: :customer_facing, current: 2.5, ...}]
result.recommendation #=> "6-12ヶ月後に再評価。重点改善領域: customer_facing"

# app/services/career_decision_framework.rb
class CareerDecisionFramework
  FACTORS = {
    income_priority: {
      high: -> { "フロンティア AI ラボの FDE → Staff 以上を目指す" },
      medium: -> { "エンタープライズ SaaS で安定した成長を狙う" },
      low: -> { "起業やコンサルなど、自由度を優先" }
    },
    risk_tolerance: {
      high: -> { "アーリーステージのスタートアップ FDE（株式報酬のアップサイド）" },
      medium: -> { "Series B+ で PMF 達成済みの企業" },
      low: -> { "Fortune 500 のデジタル部門（安定性重視）" }
    },
    people_orientation: {
      high: -> { "マネジメントトラック（Lead → Director）" },
      medium: -> { "IC トラック（Staff FDE → Field CTO）" },
      low: -> { "技術特化（R&D 転向 or 起業）" }
    }
  }.freeze
 
  def initialize(preferences)
    @preferences = preferences
  end
 
  def recommend
    FACTORS.map { |factor, options|
      level = @preferences[factor] || :medium
      { factor:, level:, path: options[level].call }
    }
  end
end