PoC の設計と実行 — 「動く」と「使える」の間にある深い溝

# SMART 成功基準の定義
class PocSuccessCriteria
  CRITERIA = [
    {
      id: "SC-001", category: :performance,
      description: "87件の配送ルート最適化を10秒以内に完了",
      target: "P95 ≤ 10,000ms", priority: :must_have
    },
    {
      id: "SC-002", category: :accuracy,
      description: "LIFO積載制約の充足率 100%",
      target: "制約違反 0%", priority: :must_have
    },
    {
      id: "SC-003", category: :efficiency,
      description: "手動配車比で走行距離 15% 以上削減",
      target: "削減率 ≥ 15%", priority: :must_have
    },
    {
      id: "SC-004", category: :integration,
      description: "SAP TM から配送オーダーを自動取得",
      target: "同期成功率 ≥ 99.0%", priority: :should_have
    },
    {
      id: "SC-005", category: :usability,
      description: "オペレーターが30分以内に操作習得",
      target: "初回正答率 ≥ 80%", priority: :nice_to_have
    }
  ].freeze
 
  def evaluate(results)
    must_haves = CRITERIA.select { |c| c[:priority] == :must_have }
    all_must_pass = must_haves.all? { |c| results[c[:id]][:passed] }
 
    { verdict: all_must_pass ? :go : :no_go,
      must_have_pass_rate: calc_rate(must_haves, results) }
  end
 
  private
 
  def calc_rate(criteria, results)
    passed = criteria.count { |c| results[c[:id]][:passed] }
    (passed.to_f / criteria.size * 100).round(1)
  end
end

# テナント管理モデル
class PocTenant < ApplicationRecord
  validates :slug, presence: true, uniqueness: true,
                   format: { with: /\A[a-z0-9\-]+\z/ }
  validates :company_name, presence: true
  validates :poc_start_date, presence: true
  validates :poc_end_date, presence: true
 
  has_many :delivery_orders, dependent: :destroy
  has_many :route_optimizations, dependent: :destroy
 
  def active?
    today = Date.current
    poc_start_date <= today && today <= poc_end_date
  end
 
  # テナント固有の最適化設定
  def optimization_config
    config = { constraints: %i[time_window vehicle_capacity] }
    config[:constraints] << :lifo_loading if slug == "yamamoto-logistics"
    config
  end
end

# リクエストごとにテナントを識別・設定するミドルウェア
class TenantMiddleware
  def initialize(app)
    @app = app
  end
 
  def call(env)
    request = ActionDispatch::Request.new(env)
    tenant = resolve_tenant(request)
 
    return tenant_not_found if tenant.nil?
    return poc_expired unless tenant.active?
 
    Current.tenant = tenant
    @app.call(env)
  ensure
    Current.tenant = nil
  end
 
  private
 
  def resolve_tenant(request)
    slug = request.headers["X-Tenant-ID"]
    slug ||= request.host.split(".").first if request.host.split(".").length > 2
    PocTenant.find_by(slug: slug)
  end
 
  def tenant_not_found
    [404, json_header, ['{"error":"Tenant not found"}']]
  end
 
  def poc_expired
    [403, json_header, ['{"error":"PoC period has expired"}']]
  end
 
  def json_header
    { "Content-Type" => "application/json" }
  end
end

# 全モデルに適用するテナントスコープ
module TenantScoped
  extend ActiveSupport::Concern
 
  included do
    belongs_to :poc_tenant
    default_scope -> { where(poc_tenant: Current.tenant) if Current.tenant }
    validates :poc_tenant, presence: true
    before_validation :set_tenant, on: :create
  end
 
  private
 
  def set_tenant
    self.poc_tenant ||= Current.tenant
  end
end
 
class Current < ActiveSupport::CurrentAttributes
  attribute :tenant
end
 
class DeliveryOrder < ApplicationRecord
  include TenantScoped
 
  has_many :delivery_items, dependent: :destroy
  validates :scheduled_date, presence: true
  validates :destination_address, presence: true
 
  scope :for_date, ->(date) { where(scheduled_date: date) }
  scope :unassigned, -> { where(driver: nil) }
end

class Api::V1::RouteOptimizationsController < ApplicationController
  before_action :verify_poc_active!
 
  def create
    orders = DeliveryOrder.for_date(params[:date]).unassigned
    config = Current.tenant.optimization_config
 
    result = ArclightClient.optimize(
      orders: orders.map(&:to_optimization_params),
      constraints: config[:constraints]
    )
 
    # PoC 結果の記録（Phase 4 の評価に使う）
    PocResult.create!(
      poc_tenant: Current.tenant,
      request_params: { order_count: orders.size, date: params[:date] },
      response_time_ms: result.elapsed_ms,
      optimization_result: result.to_h,
      success: result.success?
    )
 
    render json: {
      optimization: result.routes,
      metrics: {
        total_distance_km: result.total_distance_km,
        reduction_rate: result.distance_reduction_rate,
        constraint_violations: result.violations.count,
        response_time_ms: result.elapsed_ms
      }
    }, status: :created
  end
 
  private
 
  def verify_poc_active!
    return if Current.tenant&.active?
    render json: { error: "PoC period is not active" }, status: :forbidden
  end
end

import * as cdk from "aws-cdk-lib";
import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as rds from "aws-cdk-lib/aws-rds";
 
interface PocStackProps extends cdk.StackProps {
  tenantSlug: string;
  pocEndDate: string;
}
 
class PocEnvironmentStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props: PocStackProps) {
    super(scope, id, props);
 
    const vpc = new ec2.Vpc(this, "PocVpc", {
      maxAzs: 2,
      natGateways: 1, // コスト削減
    });
 
    // PoC はスモールインスタンスで十分
    const db = new rds.DatabaseInstance(this, "PocDb", {
      engine: rds.DatabaseInstanceEngine.postgres({
        version: rds.PostgresEngineVersion.VER_16,
      }),
      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T4G, ec2.InstanceSize.SMALL),
      vpc,
      databaseName: `poc_${props.tenantSlug.replace(/-/g, "_")}`,
      backupRetention: cdk.Duration.days(3),
      removalPolicy: cdk.RemovalPolicy.DESTROY, // PoC 終了後に削除可能
    });
 
    // PoC 終了日に自動削除するタグ
    cdk.Tags.of(this).add("poc:tenant", props.tenantSlug);
    cdk.Tags.of(this).add("poc:end-date", props.pocEndDate);
    cdk.Tags.of(this).add("auto-delete", "true");
  }
}

cdk deploy PocStack-yamamoto \
  --context tenantSlug=yamamoto-logistics \
  --context pocEndDate=2026-07-21

# PoC 完了後のナレッジ記録
class PocPostMortem
  def initialize(poc_plan:, results:)
    @poc_plan = poc_plan
    @results = results
    @learnings = []
  end
 
  def record_learning(category:, description:, action:)
    @learnings << { category: category, description: description,
                    action: action, recorded_at: Time.current }
  end
 
  def recommendation
    if @results[:verdict] == :go
      "PoV フェーズへの移行を推奨。本番環境の要件定義を開始すること。"
    else
      failed = @results[:details].reject { |d| d[:passed] }
      "未達基準: #{failed.map { |d| d[:id] }.join(', ')}。再 PoC または代替アプローチの検討を推奨。"
    end
  end
end

# ヤマモト物流の業務制約をコード化
class YamamotoConstraints
  CONSTRAINTS = {
    lifo_loading: {
      type: :hard,  # 必ず満たす
      description: "積載順序はLIFO（後入れ先出し）"
    },
    time_window: {
      type: :hard,
      description: "配送先の時間指定を厳守"
    },
    max_work_hours: {
      type: :hard,
      description: "1日の稼働時間 ≤ 10時間（労基法準拠）"
    },
    refrigerated: {
      type: :hard,
      description: "冷蔵品は冷蔵車に限定"
    },
    lunch_break: {
      type: :soft,  # できれば満たす
      description: "12:00-13:00 に 45 分以上の休憩",
      penalty_weight: 0.8
    }
  }.freeze
end