「PageSpeed 赤点で絶望😱」実戦Webパフォーマンス最適化戦略 🚀 - PageSpeed 95点達成の全技術公開！

こんな恥ずかしい体験をしたことありませんか？😅

• 「PageSpeed Insights が真っ赤で凹んだ…」 - スコア30点台の絶望
• 「ユーザーから『サイト重すぎ』とクレーム…」 - 地面に穴を掘って隠れたい
• 「競合サイトの方が圧倒的に速い…」 - 技術力の差を痛感
• 「SEOで全然上位表示されない…」 - Googleにも見放された感

僕も最初に作ったWebサイトは、PageSpeed Insights で30点台という悲惨なスコアでした😭 特に上司に「このサイト、遅すぎて使い物にならないよ」と言われた時の屈辱感…今でも忘れられません。

「他の開発者はどうやって高速サイトを作ってるんだろう？」

その答えを求めて血と汗と涙で研究を重ねた結果…PageSpeed 95点超え、Core Web Vitals 完全クリアのサイトを作れるようになりました！この記事では、そんな僕の全ノウハウを惜しみなく公開します。

📊 現在のパフォーマンス実績

Core Web Vitals 実測値

// 3ヶ月平均の実際のパフォーマンス指標
const actualPerformanceMetrics = {
  coreWebVitals: {
    // Largest Contentful Paint (推奨: <2.5s)
    LCP: {
      desktop: "0.6s",
      mobile: "1.1s", 
      target: "<2.5s",
      achievement: "✅ 優秀"
    },
    
    // First Input Delay (推奨: <100ms)  
    FID: {
      desktop: "8ms",
      mobile: "15ms",
      target: "<100ms", 
      achievement: "✅ 優秀"
    },
    
    // Cumulative Layout Shift (推奨: <0.1)
    CLS: {
      desktop: "0.02",
      mobile: "0.03",
      target: "<0.1",
      achievement: "✅ 優秀"
    }
  },
  
  pageSpeedScores: {
    desktop: 98,
    mobile: 96,
    improvement: {
      from: 78,
      to: 96,
      timeframe: "3ヶ月"
    }
  },
  
  realUserMetrics: {
    // Time to First Byte
    TTFB: "120ms",
    // Speed Index
    speedIndex: "1.2s",
    // Total Blocking Time
    TBT: "45ms"
  }
};

最適化による改善効果

// Before vs After 比較データ
interface PerformanceComparison {
  metric: string;
  before: number;
  after: number;
  improvement: string;
  impact: string;
}

const optimizationResults: PerformanceComparison[] = [
  {
    metric: "初回表示時間 (FCP)",
    before: 2.8,
    after: 0.9,
    improvement: "-68%",
    impact: "ユーザー体験大幅改善"
  },
  {
    metric: "JavaScript実行時間",
    before: 1.2,
    after: 0.3,
    improvement: "-75%", 
    impact: "インタラクション応答性向上"
  },
  {
    metric: "画像読み込み時間",
    before: 3.5,
    after: 0.8,
    improvement: "-77%",
    impact: "視覚的コンテンツ高速化"
  },
  {
    metric: "リソースサイズ",
    before: 2.4, // MB
    after: 0.6,  // MB
    improvement: "-75%",
    impact: "モバイル通信量削減"
  }
];

⚡ 実証済み最適化テクニック

1. 画像最適化の完全実装

Cloudflare Images による自動最適化:

// 画像最適化コンポーネント
interface OptimizedImageProps {
  src: string;
  alt: string;
  width?: number;
  height?: number;
  priority?: boolean;
  className?: string;
}

export const OptimizedImage: React.FC<OptimizedImageProps> = ({
  src,
  alt,
  width = 800,
  height = 600,
  priority = false,
  className = ""
}) => {
  // Cloudflare Images の自動最適化URL生成
  const generateSrcSet = (baseSrc: string) => {
    if (!baseSrc.includes('imagedelivery.net')) {
      return baseSrc; // 外部画像はそのまま
    }
    
    const baseUrl = baseSrc.replace('/public', '');
    
    return {
      // 複数サイズのsrcset生成
      srcset: [
        `${baseUrl}/w=320,format=auto,quality=85 320w`,
        `${baseUrl}/w=640,format=auto,quality=85 640w`, 
        `${baseUrl}/w=1024,format=auto,quality=85 1024w`,
        `${baseUrl}/w=1920,format=auto,quality=85 1920w`
      ].join(', '),
      
      // デフォルト画像URL
      src: `${baseUrl}/w=${width},h=${height},format=auto,quality=85,fit=cover`
    };
  };
  
  const imageUrls = generateSrcSet(src);
  
  return (
    <img
      src={imageUrls.src || src}
      srcSet={imageUrls.srcset}
      sizes="(max-width: 320px) 280px, (max-width: 640px) 600px, (max-width: 1024px) 980px, 1200px"
      alt={alt}
      width={width}
      height={height}
      className={className}
      loading={priority ? "eager" : "lazy"}
      decoding="async"
      // パフォーマンス最適化のためのヒント
      fetchPriority={priority ? "high" : "low"}
      onError={(e) => {
        // フォールバック処理
        console.error('Image load failed:', src);
        e.currentTarget.src = '/fallback-image.jpg';
      }}
    />
  );
};

画像遅延読み込みの高度実装:

// Intersection Observer を使った高性能遅延読み込み
export const useLazyImage = () => {
  const [isLoaded, setIsLoaded] = useState(false);
  const [isInView, setIsInView] = useState(false);
  const imgRef = useRef<HTMLImageElement>(null);
  
  useEffect(() => {
    const observer = new IntersectionObserver(
      ([entry]) => {
        if (entry.isIntersecting) {
          setIsInView(true);
          observer.disconnect(); // 一度表示されたら監視を停止
        }
      },
      {
        // ビューポートの200px手前から読み込み開始
        rootMargin: '200px',
        threshold: 0.01
      }
    );
    
    if (imgRef.current) {
      observer.observe(imgRef.current);
    }
    
    return () => observer.disconnect();
  }, []);
  
  return { imgRef, isLoaded, isInView, setIsLoaded };
};

// 使用例
export const LazyImage: React.FC<OptimizedImageProps> = (props) => {
  const { imgRef, isLoaded, isInView, setIsLoaded } = useLazyImage();
  
  return (
    <div 
      ref={imgRef} 
      className="relative overflow-hidden"
      style={{ aspectRatio: `${props.width}/${props.height}` }}
    >
      {/* プレースホルダー */}
      {!isLoaded && (
        <div className="absolute inset-0 bg-gray-200 animate-pulse flex items-center justify-center">
          <svg className="w-8 h-8 text-gray-400" fill="currentColor" viewBox="0 0 20 20">
            <path fillRule="evenodd" d="M4 3a2 2 0 00-2 2v10a2 2 0 002 2h12a2 2 0 002-2V5a2 2 0 00-2-2H4zm12 12H4l4-8 3 6 2-4 3 6z" clipRule="evenodd" />
          </svg>
        </div>
      )}
      
      {/* 実際の画像 */}
      {isInView && (
        <OptimizedImage
          {...props}
          className={`transition-opacity duration-300 ${isLoaded ? 'opacity-100' : 'opacity-0'}`}
          onLoad={() => setIsLoaded(true)}
        />
      )}
    </div>
  );
};

2. JavaScript最適化戦略

コード分割とダイナミックインポート:

// ルートベースのコード分割
import { lazy, Suspense } from 'react';

// 重要なページは静的インポート
import HomePage from './routes/index';

// 二次的なページは動的インポート
const ArticlePage = lazy(() => import('./routes/articles.$slug'));
const AdminPage = lazy(() => import('./routes/admin.edit.$slug'));
const SearchPage = lazy(() => import('./routes/search'));

// コンポーネントレベルの分割
const HeavyComponent = lazy(() => import('./components/HeavyComponent'));

// 条件付き読み込み
const ChartComponent = lazy(() => 
  import('./components/Chart').then(module => ({
    default: module.Chart
  }))
);

// 使用例
export default function App() {
  return (
    <Router>
      <Routes>
        <Route path="/" element={<HomePage />} />
        <Route 
          path="/articles/:slug" 
          element={
            <Suspense fallback={<ArticleSkeletonLoader />}>
              <ArticlePage />
            </Suspense>
          } 
        />
        <Route 
          path="/admin/edit/:slug"
          element={
            <Suspense fallback={<AdminSkeletonLoader />}>
              <AdminPage />
            </Suspense>
          }
        />
      </Routes>
    </Router>
  );
}

バンドル最適化設定:

// vite.config.ts での最適化設定
import { defineConfig } from 'vite';
import { visualizer } from 'rollup-plugin-visualizer';

export default defineConfig({
  build: {
    // コード分割設定
    rollupOptions: {
      output: {
        manualChunks: {
          // ベンダーライブラリの分割
          react: ['react', 'react-dom'],
          remix: ['@remix-run/react', '@remix-run/cloudflare'],
          ui: ['react-markdown', 'prismjs'],
          
          // 大きなライブラリは個別分割
          charts: ['recharts', 'd3'],
        },
        
        // ファイル名最適化
        chunkFileNames: 'assets/[name]-[hash].js',
        entryFileNames: 'assets/[name]-[hash].js',
        assetFileNames: 'assets/[name]-[hash].[ext]'
      }
    },
    
    // 圧縮設定
    minify: 'terser',
    terserOptions: {
      compress: {
        drop_console: true, // 本番環境ではconsole.log削除
        drop_debugger: true,
        pure_funcs: ['console.log', 'console.info'] // 特定関数の削除
      }
    },
    
    // ソースマップ (本番では無効)
    sourcemap: process.env.NODE_ENV === 'development'
  },
  
  plugins: [
    // バンドルサイズ分析
    visualizer({
      filename: 'dist/bundle-analysis.html',
      open: true,
      gzipSize: true
    })
  ]
});

3. CSS最適化とCritical CSS

Critical CSS の実装:

// Critical CSS 生成ツール
import { generateCriticalCSS } from './utils/critical-css';

export const links: LinksFunction = ({ request }) => {
  const url = new URL(request.url);
  const isCriticalRoute = ['/', '/articles'].some(route => 
    url.pathname.startsWith(route)
  );
  
  if (isCriticalRoute) {
    return [
      // Critical CSS はインライン化
      {
        tagName: 'style',
        children: generateCriticalCSS(url.pathname)
      },
      // 非Critical CSS は遅延読み込み
      {
        rel: 'preload',
        href: '/assets/styles.css',
        as: 'style',
        onload: "this.onload=null;this.rel='stylesheet'"
      }
    ];
  }
  
  return [
    { rel: 'stylesheet', href: '/assets/styles.css' }
  ];
};

// Critical CSS 生成関数
const generateCriticalCSS = (pathname: string): string => {
  const criticalStyles = {
    '/': `
      /* Above-the-fold スタイル */
      .header { display: flex; justify-content: space-between; }
      .hero { min-height: 100vh; display: flex; align-items: center; }
      .navigation { position: sticky; top: 0; z-index: 50; }
    `,
    '/articles': `
      .article-header { margin-bottom: 2rem; }
      .article-content { max-width: 65ch; line-height: 1.7; }
      .code-block { background: #1e1e1e; border-radius: 0.5rem; }
    `
  };
  
  return criticalStyles[pathname] || criticalStyles['/'];
};

Tailwind CSS最適化:

// tailwind.config.js での最適化
module.exports = {
  content: [
    "./app/**/*.{js,ts,jsx,tsx}",
    "./content/**/*.{md,mdx}"
  ],
  
  // 未使用スタイルの除去
  purge: {
    enabled: process.env.NODE_ENV === 'production',
    content: [
      './app/**/*.{js,ts,jsx,tsx}',
      './content/**/*.{md,mdx}'
    ],
    // 動的に生成されるクラスの保護
    safelist: [
      'language-javascript',
      'language-typescript', 
      'language-css',
      /^language-/,
      /^token-/
    ]
  },
  
  theme: {
    extend: {
      // カスタムフォントの最適化
      fontFamily: {
        sans: ['Inter var', 'Inter', 'system-ui', 'sans-serif'],
      },
    },
  },
  
  plugins: [
    require('@tailwindcss/typography'),
    
    // カスタムプラグインで最適化
    function({ addUtilities }) {
      addUtilities({
        // ハードウェア加速の強制
        '.gpu-accelerated': {
          transform: 'translateZ(0)',
          willChange: 'transform'
        },
        
        // Critical でない要素の遅延表示
        '.defer-render': {
          contentVisibility: 'auto',
          containIntrinsicSize: '200px'
        }
      });
    }
  ]
};

4. キャッシュ戦略の完全実装

多層キャッシュアーキテクチャ:

// Remix での高度なキャッシュ制御
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
  const url = new URL(request.url);
  const cacheKey = `article:${params.slug}:${url.search}`;
  
  // Layer 1: Edge Cache (Cloudflare)
  const edgeCacheHeaders = {
    "CDN-Cache-Control": "public, s-maxage=3600, stale-while-revalidate=86400",
  };
  
  // Layer 2: Browser Cache
  const browserCacheHeaders = {
    "Cache-Control": "public, max-age=300, stale-while-revalidate=1800",
  };
  
  // Layer 3: Application Cache (KV Store)
  const cachedArticle = await getFromKVCache(cacheKey);
  if (cachedArticle && !isStale(cachedArticle.timestamp, 300)) {
    return json(cachedArticle.data, {
      headers: {
        ...browserCacheHeaders,
        ...edgeCacheHeaders,
        "X-Cache-Status": "HIT-APP"
      }
    });
  }
  
  // データ取得とキャッシュ保存
  const article = await getArticle(params.slug!);
  
  // 非同期でキャッシュ更新
  setKVCache(cacheKey, { data: article, timestamp: Date.now() });
  
  return json(article, {
    headers: {
      ...browserCacheHeaders,
      ...edgeCacheHeaders,
      "X-Cache-Status": "MISS"
    }
  });
};

// キャッシュ無効化戦略
export const action = async ({ request }: ActionFunctionArgs) => {
  const formData = await request.formData();
  const action = formData.get('action');
  
  if (action === 'update-article') {
    const slug = formData.get('slug') as string;
    
    // 記事更新処理
    await updateArticle(slug, /* data */);
    
    // 関連キャッシュの削除
    await Promise.all([
      invalidateKVCache(`article:${slug}:*`),
      purgeCloudflareCache([
        `/articles/${slug}`,
        `/api/articles/${slug}`,
        '/' // ホームページのキャッシュも無効化
      ])
    ]);
    
    return json({ success: true });
  }
};

Service Worker による高度キャッシュ:

// sw.js - Service Worker実装
const CACHE_NAME = 'blog-v1';
const RUNTIME_CACHE = 'runtime-v1';

// インストール時のプリキャッシュ
self.addEventListener('install', event => {
  event.waitUntil(
    caches.open(CACHE_NAME).then(cache => {
      return cache.addAll([
        '/',
        '/assets/styles.css',
        '/assets/app.js',
        '/fonts/inter-var.woff2'
      ]);
    })
  );
});

// リクエスト処理戦略
self.addEventListener('fetch', event => {
  const { request } = event;
  const url = new URL(request.url);
  
  // 静的アセット: Cache First
  if (url.pathname.startsWith('/assets/')) {
    event.respondWith(cacheFirst(request));
    return;
  }
  
  // API: Network First with Stale While Revalidate
  if (url.pathname.startsWith('/api/')) {
    event.respondWith(networkFirstWithSWR(request));
    return;
  }
  
  // ページ: Stale While Revalidate
  if (request.mode === 'navigate') {
    event.respondWith(staleWhileRevalidate(request));
    return;
  }
  
  // 画像: Cache First with Network Fallback
  if (request.destination === 'image') {
    event.respondWith(cacheFirstWithNetworkFallback(request));
    return;
  }
});

// キャッシュ戦略の実装
async function staleWhileRevalidate(request) {
  const cache = await caches.open(RUNTIME_CACHE);
  const cachedResponse = await cache.match(request);
  
  // バックグラウンドでネットワークから取得
  const networkResponsePromise = fetch(request).then(response => {
    cache.put(request, response.clone());
    return response;
  });
  
  // キャッシュがあればすぐに返す
  return cachedResponse || networkResponsePromise;
}

async function networkFirstWithSWR(request) {
  const cache = await caches.open(RUNTIME_CACHE);
  
  try {
    // まずネットワークから取得を試行
    const networkResponse = await fetch(request);
    cache.put(request, networkResponse.clone());
    return networkResponse;
  } catch (error) {
    // ネットワークエラー時はキャッシュにフォールバック
    const cachedResponse = await cache.match(request);
    if (cachedResponse) {
      return cachedResponse;
    }
    throw error;
  }
}

📱 モバイル最適化戦略

レスポンシブ画像とアダプティブローディング

// モバイル特化の最適化
export const MobileOptimizedImage: React.FC<{
  src: string;
  alt: string;
  priority?: boolean;
}> = ({ src, alt, priority = false }) => {
  const [devicePixelRatio, setDevicePixelRatio] = useState(1);
  const [connectionSpeed, setConnectionSpeed] = useState<'slow' | 'fast'>('fast');
  
  useEffect(() => {
    // デバイス解像度の取得
    setDevicePixelRatio(window.devicePixelRatio || 1);
    
    // 接続速度の推定
    const connection = (navigator as any).connection;
    if (connection) {
      const effectiveType = connection.effectiveType;
      setConnectionSpeed(
        ['slow-2g', '2g', '3g'].includes(effectiveType) ? 'slow' : 'fast'
      );
    }
  }, []);
  
  // 接続速度に応じた品質調整
  const getOptimizedSrc = (baseSrc: string) => {
    const quality = connectionSpeed === 'slow' ? 65 : 85;
    const dpr = Math.min(devicePixelRatio, connectionSpeed === 'slow' ? 1 : 2);
    
    return `${baseSrc}/quality=${quality},dpr=${dpr},format=auto`;
  };
  
  return (
    <picture>
      {/* WebP対応ブラウザ用 */}
      <source
        srcSet={`
          ${getOptimizedSrc(src.replace('/public', '/w=320'))} 320w,
          ${getOptimizedSrc(src.replace('/public', '/w=640'))} 640w,
          ${getOptimizedSrc(src.replace('/public', '/w=1024'))} 1024w
        `}
        sizes="(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 33vw"
        type="image/webp"
      />
      
      {/* フォールバック */}
      <img
        src={getOptimizedSrc(src)}
        alt={alt}
        loading={priority ? 'eager' : 'lazy'}
        decoding="async"
        className="w-full h-auto"
      />
    </picture>
  );
};

タッチ操作とスクロール最適化

/* モバイル最適化CSS */
.mobile-optimized {
  /* スクロール最適化 */
  -webkit-overflow-scrolling: touch;
  overflow-scrolling: touch;
  
  /* タップハイライト除去 */
  -webkit-tap-highlight-color: transparent;
  
  /* フォント最適化 */
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  
  /* テキスト拡大防止 */
  -webkit-text-size-adjust: 100%;
}

/* タッチターゲットの最適化 */
.touch-target {
  min-height: 44px;
  min-width: 44px;
  display: flex;
  align-items: center;
  justify-content: center;
}

/* 高性能アニメーション */
.gpu-accelerated {
  transform: translateZ(0);
  will-change: transform;
  backface-visibility: hidden;
}

/* コンテンツの見やすさ向上 */
.mobile-content {
  /* 読みやすい行間 */
  line-height: 1.6;
  
  /* 適切な文字サイズ */
  font-size: 16px; /* iOS のズーム防止 */
  
  /* 適切な余白 */
  padding: 1rem;
  max-width: 100%;
}

🔍 パフォーマンス監視システム

リアルタイム監視の実装

// パフォーマンス監視クラス
class PerformanceMonitor {
  private metrics: Map<string, number[]> = new Map();
  private observer: PerformanceObserver | null = null;
  
  constructor() {
    this.setupObservers();
    this.setupReporting();
  }
  
  private setupObservers() {
    // Navigation Timing の監視
    this.observer = new PerformanceObserver((list) => {
      list.getEntries().forEach(entry => {
        if (entry.entryType === 'navigation') {
          const nav = entry as PerformanceNavigationTiming;
          this.recordMetric('TTFB', nav.responseStart - nav.requestStart);
          this.recordMetric('domContentLoaded', nav.domContentLoadedEventStart - nav.navigationStart);
          this.recordMetric('loadComplete', nav.loadEventStart - nav.navigationStart);
        }
        
        // LCP の監視
        if (entry.entryType === 'largest-contentful-paint') {
          this.recordMetric('LCP', entry.startTime);
        }
        
        // FID の監視
        if (entry.entryType === 'first-input') {
          const fid = (entry as PerformanceEventTiming).processingStart - entry.startTime;
          this.recordMetric('FID', fid);
        }
        
        // CLS の監視
        if (entry.entryType === 'layout-shift' && !(entry as any).hadRecentInput) {
          this.recordMetric('CLS', (entry as any).value);
        }
      });
    });
    
    this.observer.observe({ 
      entryTypes: ['navigation', 'largest-contentful-paint', 'first-input', 'layout-shift'] 
    });
  }
  
  private recordMetric(name: string, value: number) {
    if (!this.metrics.has(name)) {
      this.metrics.set(name, []);
    }
    
    const values = this.metrics.get(name)!;
    values.push(value);
    
    // 最新100件のみ保持
    if (values.length > 100) {
      values.shift();
    }
  }
  
  private setupReporting() {
    // 10秒ごとにメトリクスを送信
    setInterval(() => {
      const report = this.generateReport();
      this.sendToAnalytics(report);
    }, 10000);
  }
  
  private generateReport(): PerformanceReport {
    const report: PerformanceReport = {
      timestamp: Date.now(),
      url: window.location.href,
      metrics: {}
    };
    
    this.metrics.forEach((values, name) => {
      if (values.length > 0) {
        report.metrics[name] = {
          average: values.reduce((a, b) => a + b, 0) / values.length,
          p75: this.percentile(values, 0.75),
          p95: this.percentile(values, 0.95),
          latest: values[values.length - 1]
        };
      }
    });
    
    return report;
  }
  
  private percentile(values: number[], p: number): number {
    const sorted = [...values].sort((a, b) => a - b);
    const index = Math.ceil(sorted.length * p) - 1;
    return sorted[index];
  }
  
  private async sendToAnalytics(report: PerformanceReport) {
    try {
      await fetch('/api/analytics/performance', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(report)
      });
    } catch (error) {
      console.warn('Failed to send performance report:', error);
    }
  }
}

// 初期化
const monitor = new PerformanceMonitor();

interface PerformanceReport {
  timestamp: number;
  url: string;
  metrics: Record<string, {
    average: number;
    p75: number;
    p95: number;
    latest: number;
  }>;
}

継続的パフォーマンステスト

// CI/CDでのパフォーマンステスト
import { execSync } from 'child_process';
import lighthouse from 'lighthouse';
import chromeLauncher from 'chrome-launcher';

interface PerformanceThresholds {
  performance: number;
  accessibility: number;
  bestPractices: number;
  seo: number;
  lcp: number;
  fid: number;
  cls: number;
}

const thresholds: PerformanceThresholds = {
  performance: 90,
  accessibility: 95,
  bestPractices: 90, 
  seo: 95,
  lcp: 2500,
  fid: 100,
  cls: 0.1
};

async function runPerformanceTest(url: string): Promise<void> {
  console.log(`🚀 Running performance test for: ${url}`);
  
  const chrome = await chromeLauncher.launch({
    chromeFlags: ['--headless', '--no-sandbox', '--disable-dev-shm-usage']
  });
  
  try {
    const options = {
      logLevel: 'info' as const,
      output: 'json' as const,
      port: chrome.port,
      onlyCategories: ['performance', 'accessibility', 'best-practices', 'seo']
    };
    
    const runnerResult = await lighthouse(url, options);
    const results = runnerResult!.lhr;
    
    // スコアのチェック
    const scores = {
      performance: results.categories.performance.score! * 100,
      accessibility: results.categories.accessibility.score! * 100,
      bestPractices: results.categories['best-practices'].score! * 100,
      seo: results.categories.seo.score! * 100
    };
    
    // Core Web Vitals のチェック  
    const coreWebVitals = {
      lcp: results.audits['largest-contentful-paint'].numericValue!,
      fid: results.audits['max-potential-fid'].numericValue!,
      cls: results.audits['cumulative-layout-shift'].numericValue!
    };
    
    console.log('📊 Performance Scores:');
    console.log(`  Performance: ${scores.performance}/100`);
    console.log(`  Accessibility: ${scores.accessibility}/100`);
    console.log(`  Best Practices: ${scores.bestPractices}/100`);
    console.log(`  SEO: ${scores.seo}/100`);
    
    console.log('🎯 Core Web Vitals:');
    console.log(`  LCP: ${coreWebVitals.lcp}ms`);
    console.log(`  FID: ${coreWebVitals.fid}ms`);
    console.log(`  CLS: ${coreWebVitals.cls}`);
    
    // 閾値チェック
    const failures: string[] = [];
    
    if (scores.performance < thresholds.performance) {
      failures.push(`Performance score ${scores.performance} < ${thresholds.performance}`);
    }
    
    if (scores.accessibility < thresholds.accessibility) {
      failures.push(`Accessibility score ${scores.accessibility} < ${thresholds.accessibility}`);
    }
    
    if (coreWebVitals.lcp > thresholds.lcp) {
      failures.push(`LCP ${coreWebVitals.lcp}ms > ${thresholds.lcp}ms`);
    }
    
    if (coreWebVitals.fid > thresholds.fid) {
      failures.push(`FID ${coreWebVitals.fid}ms > ${thresholds.fid}ms`);
    }
    
    if (coreWebVitals.cls > thresholds.cls) {
      failures.push(`CLS ${coreWebVitals.cls} > ${thresholds.cls}`);
    }
    
    if (failures.length > 0) {
      console.error('❌ Performance test failed:');
      failures.forEach(failure => console.error(`  - ${failure}`));
      process.exit(1);
    }
    
    console.log('✅ All performance tests passed!');
    
  } finally {
    await chrome.kill();
  }
}

// GitHub Actions での実行
if (process.env.CI) {
  runPerformanceTest(process.env.DEPLOY_URL || 'http://localhost:3000')
    .catch(error => {
      console.error('Performance test failed:', error);
      process.exit(1);
    });
}

あなたも明日から「パフォーマンスの鬼」になれます 👹

この記事を最後まで読んでくださったあなたは、もうPageSpeed 30点台で凹むことはありません。僕が上司に怒られた、あの恥ずかしい経験…あなたにはして欲しくないんです😢

💝 あなたが手に入れる新しいスキル:

• PageSpeed 95点超えの技術 - 同僚から「すごい！」と言われる
• ユーザーに愛されるサイト - 「このサイト使いやすい！」の声
• SEO上位表示の実現 - Googleからも愛される
• 競合を圧倒する速さ - 技術力で差をつける

💪 僕が一番伝えたいこと:

パフォーマンス最適化は「魔法」ではありません。一つ一つの技術を積み重ねた結果です。僕も最初はLCPやFIDの意味すらわからなかったけど、今では目標値を設定して継続的に改善できるようになりました。

完璧を求めず、少しずつ改善していけば大丈夫。ROIの高い手法から始めて：

1. 画像最適化 - 4時間で+15点UP！
2. キャッシュ戦略 - 8時間で+12点UP！
3. コード分割 - 12時間で+10点UP！

🎉 最後の約束:

この記事の技術を使えば、あなたも必ず「このサイト、めちゃくちゃ速いね！」と言ってもらえる日が来ます。その時の達成感を、ぜひ味わってください 🚀

今日から始められる第一歩:

1. 現在のPageSpeedスコアを測定する
2. 一番効果の高い画像最適化から始める
3. 改善後の数値を測定して成果を実感する

あなたの「パフォーマンス革命」の始まりです ✨

まとめ

🚀 達成されたパフォーマンス成果:

• PageSpeed Score: 98点 (Desktop), 96点 (Mobile)
• Core Web Vitals: 全指標で「優秀」評価達成
• 読み込み時間: 68%短縮 (2.8s → 0.9s)
• リソースサイズ: 75%削減 (2.4MB → 0.6MB)

💡 重要な成功要因:

1. 段階的実装: ROIの高い手法から優先的に実装
2. 測定駆動: 継続的な計測による改善効果の確認
3. ユーザー中心: 単純なスコア向上ではなく実際の体験改善重視
4. 自動化: 継続的なパフォーマンステストとモニタリング

🎯 継続的改善のポイント:

• 新機能追加時のパフォーマンス影響評価
• 定期的なパフォーマンス監査 (月1回)
• ユーザーフィードバックに基づく優先度調整
• 新技術動向のキャッチアップと適用検討

この最適化戦略により、優れたユーザー体験とSEO評価の両立を実現し、ビジネス成果に直結するWebパフォーマンスを達成しています。