스타트업 기술 스택 선택 가이드 2025: 0→1 단계에서 시리즈 B까지 기술 의사결정

┌─────────────────────────────────────────────────────┐
│              혁신 토큰 분배 예시                        │
├─────────────────────────────────────────────────────┤
│                                                     │
│  보유 혁신 토큰: 3개                                   │
│                                                     │
│  좋은 예:                                            │
│  ├── 비즈니스 모델 (혁신) ........... 토큰 1개 사용    │
│  ├── PostgreSQL (지루한 기술) ....... 토큰 0개         │
│  ├── Next.js (검증됨) .............. 토큰 0개         │
│  ├── 독자적 ML 파이프라인 (혁신) .... 토큰 1개 사용    │
│  └── 남은 토큰: 1개 (예비)                            │
│                                                     │
│  나쁜 예:                                            │
│  ├── 비즈니스 모델 (혁신) ........... 토큰 1개 사용    │
│  ├── CockroachDB (새로움) .......... 토큰 1개 사용    │
│  ├── Bun Runtime (새로움) .......... 토큰 1개 사용    │
│  ├── 독자적 ML 파이프라인 (혁신) .... 토큰 부족!       │
│  └── 남은 토큰: 0개 (위험)                            │
│                                                     │
└─────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────┐
│        아키텍처 진화 경로                            │
│                                                  │
│  Stage 0: 모놀리스 (MVP)                           │
│  ├── 단일 Next.js 앱                              │
│  ├── 단일 DB (Supabase)                           │
│  └── 단일 배포 (Vercel)                            │
│           │                                       │
│           ▼ (PMF 달성)                             │
│  Stage 1: 모듈러 모놀리스                           │
│  ├── 도메인별 모듈 분리                             │
│  ├── 내부 API 경계 정의                             │
│  └── DB 스키마 분리 시작                            │
│           │                                       │
│           ▼ (팀 10명+, 트래픽 급증)                  │
│  Stage 2: 선택적 서비스 분리                         │
│  ├── 병목 서비스만 분리                              │
│  ├── 이벤트 기반 비동기 처리 도입                     │
│  └── 캐싱 레이어 추가                               │
│           │                                       │
│           ▼ (팀 30명+, 글로벌 확장)                  │
│  Stage 3: MSA (필요한 경우에만)                      │
│  ├── 독립 배포 가능한 서비스들                        │
│  ├── 서비스 메시                                    │
│  └── 중앙 집중식 관찰 가능성                         │
└──────────────────────────────────────────────────┘

┌───────────────────────────────────────────────┐
│           MVP 기술 스택 (2025)                  │
├───────────────────────────────────────────────┤
│                                               │
│  Frontend:  Next.js 15 (App Router)           │
│  Styling:   Tailwind CSS + shadcn/ui          │
│  Backend:   Next.js API Routes / Server Actions│
│  Database:  Supabase (PostgreSQL)             │
│  Auth:      Supabase Auth / NextAuth.js       │
│  Storage:   Supabase Storage / Cloudflare R2  │
│  Deploy:    Vercel                            │
│  Analytics: PostHog (self-hosted) / Plausible │
│  Payments:  Stripe                            │
│  Email:     Resend                            │
│  Monitoring: Vercel Analytics + Sentry        │
│                                               │
│  총 월 비용: 0 ~ 50 USD                        │
│  (Vercel Free + Supabase Free Tier)           │
│                                               │
└───────────────────────────────────────────────┘

# 프로젝트 생성
npx create-next-app@latest my-startup --typescript --tailwind --app --src-dir
cd my-startup

# 핵심 의존성 설치
npm install @supabase/supabase-js @supabase/ssr
npm install stripe @stripe/stripe-js
npm install resend
npm install zod react-hook-form @hookform/resolvers

# UI 라이브러리
npx shadcn@latest init
npx shadcn@latest add button card input form dialog toast

# 개발 도구
npm install -D prettier eslint-config-prettier
npm install -D @types/node

// src/lib/supabase/server.ts
import { createServerClient } from '@supabase/ssr'
import { cookies } from 'next/headers'

export async function createClient() {
  const cookieStore = await cookies()

  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll()
        },
        setAll(cookiesToSet) {
          try {
            cookiesToSet.forEach(({ name, value, options }) =>
              cookieStore.set(name, value, options)
            )
          } catch {
            // Server Component에서는 set 불가 - 무시
          }
        },
      },
    }
  )
}

// src/lib/supabase/client.ts
import { createBrowserClient } from '@supabase/ssr'

export function createClient() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  )
}

// src/app/auth/login/page.tsx
'use client'

import { createClient } from '@/lib/supabase/client'
import { useState } from 'react'
import { useRouter } from 'next/navigation'

export default function LoginPage() {
  const [email, setEmail] = useState('')
  const [password, setPassword] = useState('')
  const [loading, setLoading] = useState(false)
  const router = useRouter()
  const supabase = createClient()

  const handleLogin = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)

    const { error } = await supabase.auth.signInWithPassword({
      email,
      password,
    })

    if (error) {
      alert(error.message)
    } else {
      router.push('/dashboard')
      router.refresh()
    }
    setLoading(false)
  }

  const handleGoogleLogin = async () => {
    await supabase.auth.signInWithOAuth({
      provider: 'google',
      options: {
        redirectTo: `${window.location.origin}/auth/callback`,
      },
    })
  }

  return (
    <div className="flex min-h-screen items-center justify-center">
      <form onSubmit={handleLogin} className="w-full max-w-md space-y-4 p-8">
        <h1 className="text-2xl font-bold">로그인</h1>
        <input
          type="email"
          placeholder="이메일"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
          className="w-full rounded border p-2"
          required
        />
        <input
          type="password"
          placeholder="비밀번호"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
          className="w-full rounded border p-2"
          required
        />
        <button
          type="submit"
          disabled={loading}
          className="w-full rounded bg-blue-600 p-2 text-white"
        >
          {loading ? '로그인 중...' : '로그인'}
        </button>
        <button
          type="button"
          onClick={handleGoogleLogin}
          className="w-full rounded border p-2"
        >
          Google로 로그인
        </button>
      </form>
    </div>
  )
}

// src/app/api/stripe/checkout/route.ts
import { NextRequest, NextResponse } from 'next/server'
import Stripe from 'stripe'
import { createClient } from '@/lib/supabase/server'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)

export async function POST(req: NextRequest) {
  const supabase = await createClient()
  const { data: { user } } = await supabase.auth.getUser()

  if (!user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  const { priceId } = await req.json()

  const session = await stripe.checkout.sessions.create({
    customer_email: user.email,
    line_items: [{ price: priceId, quantity: 1 }],
    mode: 'subscription',
    success_url: `${req.nextUrl.origin}/dashboard?success=true`,
    cancel_url: `${req.nextUrl.origin}/pricing?canceled=true`,
    metadata: {
      userId: user.id,
    },
  })

  return NextResponse.json({ url: session.url })
}

// src/app/api/stripe/webhook/route.ts
import { NextRequest, NextResponse } from 'next/server'
import Stripe from 'stripe'
import { createClient } from '@supabase/supabase-js'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const supabaseAdmin = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

export async function POST(req: NextRequest) {
  const body = await req.text()
  const sig = req.headers.get('stripe-signature')!

  let event: Stripe.Event
  try {
    event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    )
  } catch (err) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 })
  }

  switch (event.type) {
    case 'checkout.session.completed': {
      const session = event.data.object as Stripe.Checkout.Session
      const userId = session.metadata?.userId

      if (userId) {
        await supabaseAdmin
          .from('subscriptions')
          .upsert({
            user_id: userId,
            stripe_customer_id: session.customer as string,
            stripe_subscription_id: session.subscription as string,
            status: 'active',
            plan: 'pro',
          })
      }
      break
    }
    case 'customer.subscription.deleted': {
      const subscription = event.data.object as Stripe.Subscription
      await supabaseAdmin
        .from('subscriptions')
        .update({ status: 'canceled' })
        .eq('stripe_subscription_id', subscription.id)
      break
    }
  }

  return NextResponse.json({ received: true })
}

┌───────────────────────────────────────────────┐
│        Stage 1 기술 스택 업그레이드               │
├───────────────────────────────────────────────┤
│                                               │
│  Database:   Supabase Pro → 더 큰 인스턴스      │
│  Cache:      + Redis (Upstash)                │
│  Queue:      + BullMQ (Redis 기반)             │
│  Search:     + Meilisearch / Typesense        │
│  CDN:        + Cloudflare                     │
│  Monitoring: + Better Stack / Grafana Cloud   │
│  CI/CD:      GitHub Actions 고도화             │
│  Error:      Sentry Pro                       │
│                                               │
│  월 비용: 200 ~ 500 USD                        │
└───────────────────────────────────────────────┘

// src/lib/cache.ts
import { Redis } from '@upstash/redis'

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
})

export async function getCached<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttl: number = 3600 // 1시간
): Promise<T> {
  // 캐시 확인
  const cached = await redis.get<T>(key)
  if (cached !== null) {
    return cached
  }

  // 캐시 미스 - 데이터 가져오기
  const data = await fetcher()

  // 캐시에 저장
  await redis.set(key, data, { ex: ttl })

  return data
}

export async function invalidateCache(pattern: string) {
  const keys = await redis.keys(pattern)
  if (keys.length > 0) {
    await redis.del(...keys)
  }
}

// 사용 예시
// const user = await getCached(
//   `user:${userId}`,
//   () => db.user.findUnique({ where: { id: userId } }),
//   1800 // 30분
// )

// src/lib/queue.ts
import { Queue, Worker, Job } from 'bullmq'
import { Redis } from 'ioredis'

const connection = new Redis(process.env.REDIS_URL!, {
  maxRetriesPerRequest: null,
})

// 큐 정의
export const emailQueue = new Queue('email', { connection })
export const analyticsQueue = new Queue('analytics', { connection })

// 이메일 워커
const emailWorker = new Worker(
  'email',
  async (job: Job) => {
    const { to, subject, template, data } = job.data

    // 이메일 전송 로직
    console.log(`Sending email to ${to}: ${subject}`)
    // await resend.emails.send(...)
  },
  {
    connection,
    concurrency: 5,
    limiter: {
      max: 100,
      duration: 60000, // 분당 100건 제한
    },
  }
)

emailWorker.on('completed', (job) => {
  console.log(`Email job ${job.id} completed`)
})

emailWorker.on('failed', (job, err) => {
  console.error(`Email job ${job?.id} failed:`, err)
})

// 큐에 작업 추가
// await emailQueue.add('welcome', {
//   to: 'user@example.com',
//   subject: '환영합니다!',
//   template: 'welcome',
//   data: { name: '사용자' }
// })

// src/lib/monitoring.ts
import * as Sentry from '@sentry/nextjs'

// 커스텀 성능 모니터링
export function trackApiPerformance(
  name: string,
  fn: () => Promise<Response>
): Promise<Response> {
  return Sentry.startSpan(
    { name, op: 'http.server' },
    async () => {
      const start = Date.now()
      try {
        const response = await fn()
        const duration = Date.now() - start

        // 느린 API 경고
        if (duration > 2000) {
          Sentry.captureMessage(`Slow API: ${name} took ${duration}ms`, 'warning')
        }

        return response
      } catch (error) {
        Sentry.captureException(error)
        throw error
      }
    }
  )
}

// 비즈니스 메트릭 추적
export function trackBusinessEvent(
  event: string,
  properties?: Record<string, unknown>
) {
  // PostHog로 비즈니스 이벤트 전송
  // posthog.capture(event, properties)
  console.log(`[Business Event] ${event}`, properties)
}

-- 인덱스 최적화
-- 자주 조회되는 쿼리의 인덱스 추가
CREATE INDEX CONCURRENTLY idx_users_email ON users(email);
CREATE INDEX CONCURRENTLY idx_orders_user_created
  ON orders(user_id, created_at DESC);
CREATE INDEX CONCURRENTLY idx_products_category_status
  ON products(category_id, status) WHERE status = 'active';

-- 파티셔닝 (이벤트 테이블이 커질 때)
CREATE TABLE events (
  id BIGSERIAL,
  user_id UUID NOT NULL,
  event_type TEXT NOT NULL,
  payload JSONB,
  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
) PARTITION BY RANGE (created_at);

-- 월별 파티션 생성
CREATE TABLE events_2025_01 PARTITION OF events
  FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
CREATE TABLE events_2025_02 PARTITION OF events
  FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');

-- 쿼리 성능 분석
-- EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
-- SELECT * FROM orders WHERE user_id = 'xxx' ORDER BY created_at DESC LIMIT 20;

┌───────────────────────────────────────────────┐
│         Stage 2 기술 스택                       │
├───────────────────────────────────────────────┤
│                                               │
│  Compute:     AWS ECS Fargate / GKE           │
│  Database:    RDS PostgreSQL Multi-AZ         │
│  Cache:       ElastiCache Redis Cluster       │
│  CDN:         CloudFront + S3                 │
│  Queue:       SQS / RabbitMQ                  │
│  Search:      ElasticSearch / OpenSearch      │
│  CI/CD:       GitHub Actions + ArgoCD         │
│  Monitoring:  Datadog / Grafana Stack         │
│  Log:         CloudWatch / Loki               │
│  IaC:         Terraform                       │
│                                               │
│  팀 규모: 10-30명                              │
│  월 비용: 2,000 ~ 10,000 USD                   │
└───────────────────────────────────────────────┘

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-server
  labels:
    app: api-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-server
  template:
    metadata:
      labels:
        app: api-server
    spec:
      containers:
      - name: api
        image: my-registry/api-server:latest
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-credentials
              key: url
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 15
          periodSeconds: 20
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-server-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [main]

env:
  AWS_REGION: ap-northeast-2
  ECR_REPOSITORY: my-startup/api
  ECS_SERVICE: api-service
  ECS_CLUSTER: production

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm run type-check
      - run: npm run test

  build-and-deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build, tag, and push image
        env:
          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
          IMAGE_TAG: ${{ github.sha }}
        run: |
          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG

      - name: Deploy to ECS
        uses: aws-actions/amazon-ecs-deploy-task-definition@v2
        with:
          task-definition: task-definition.json
          service: ${{ env.ECS_SERVICE }}
          cluster: ${{ env.ECS_CLUSTER }}
          wait-for-service-stability: true

# terraform/main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }

  backend "s3" {
    bucket = "my-startup-terraform-state"
    key    = "production/terraform.tfstate"
    region = "ap-northeast-2"
  }
}

# RDS PostgreSQL
resource "aws_db_instance" "main" {
  identifier     = "my-startup-production"
  engine         = "postgres"
  engine_version = "16.1"
  instance_class = "db.r6g.large"

  allocated_storage     = 100
  max_allocated_storage = 500
  storage_encrypted     = true

  multi_az               = true
  db_subnet_group_name   = aws_db_subnet_group.main.name
  vpc_security_group_ids = [aws_security_group.rds.id]

  backup_retention_period = 14
  backup_window           = "03:00-04:00"
  maintenance_window      = "Mon:04:00-Mon:05:00"

  performance_insights_enabled = true
  monitoring_interval          = 60

  tags = {
    Environment = "production"
    Service     = "database"
  }
}

# ElastiCache Redis
resource "aws_elasticache_replication_group" "main" {
  replication_group_id       = "my-startup-cache"
  description                = "Redis cache cluster"
  node_type                  = "cache.r6g.large"
  num_cache_clusters         = 2
  automatic_failover_enabled = true
  multi_az_enabled           = true
  engine_version             = "7.0"
  port                       = 6379
  subnet_group_name          = aws_elasticache_subnet_group.main.name
  security_group_ids         = [aws_security_group.redis.id]

  at_rest_encryption_enabled = true
  transit_encryption_enabled = true
}

┌─────────────────────────────────────────────────────────┐
│                Stage 3 아키텍처                            │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐          │
│  │CloudFront│───▶│ ALB/NLB  │───▶│ K8s      │          │
│  │  + WAF   │    │          │    │ Cluster  │          │
│  └──────────┘    └──────────┘    └──────────┘          │
│                                       │                 │
│                     ┌─────────────────┼──────────┐     │
│                     │                 │          │     │
│                     ▼                 ▼          ▼     │
│              ┌───────────┐   ┌───────────┐ ┌────────┐ │
│              │API Gateway│   │  Worker    │ │ Cron   │ │
│              │  Service  │   │  Service   │ │Service │ │
│              └─────┬─────┘   └─────┬─────┘ └───┬────┘ │
│                    │               │            │      │
│      ┌─────────────┼───────────────┼────────────┤     │
│      │             │               │            │     │
│      ▼             ▼               ▼            ▼     │
│  ┌────────┐  ┌─────────┐   ┌──────────┐  ┌────────┐ │
│  │RDS     │  │Redis    │   │  Kafka   │  │  S3    │ │
│  │Multi-AZ│  │Cluster  │   │ Cluster  │  │        │ │
│  └────────┘  └─────────┘   └──────────┘  └────────┘ │
│                                    │                  │
│                              ┌─────┴─────┐           │
│                              │ElasticSearch│           │
│                              │  Cluster   │           │
│                              └───────────┘           │
│                                                       │
│  팀 규모: 30명+                                        │
│  월 비용: 10,000 USD+                                  │
└─────────────────────────────────────────────────────────┘

// src/events/producer.ts
import { Kafka, Partitioners } from 'kafkajs'

const kafka = new Kafka({
  clientId: 'my-startup',
  brokers: (process.env.KAFKA_BROKERS || '').split(','),
  ssl: true,
  sasl: {
    mechanism: 'scram-sha-256',
    username: process.env.KAFKA_USERNAME!,
    password: process.env.KAFKA_PASSWORD!,
  },
})

const producer = kafka.producer({
  createPartitioner: Partitioners.DefaultPartitioner,
  idempotent: true,
})

export async function publishEvent(topic: string, event: {
  type: string
  payload: Record<string, unknown>
  metadata?: Record<string, unknown>
}) {
  await producer.connect()

  const message = {
    key: event.payload.id as string || crypto.randomUUID(),
    value: JSON.stringify({
      ...event,
      timestamp: new Date().toISOString(),
      version: '1.0',
    }),
    headers: {
      'event-type': event.type,
      'content-type': 'application/json',
    },
  }

  await producer.send({
    topic,
    messages: [message],
  })
}

// 사용 예시
// await publishEvent('orders', {
//   type: 'order.created',
//   payload: { id: orderId, userId, items, total },
// })

// src/lib/search.ts
import { Client } from '@elastic/elasticsearch'

const esClient = new Client({
  node: process.env.ELASTICSEARCH_URL!,
  auth: {
    apiKey: process.env.ELASTICSEARCH_API_KEY!,
  },
})

// 인덱스 생성
export async function createProductIndex() {
  await esClient.indices.create({
    index: 'products',
    body: {
      settings: {
        analysis: {
          analyzer: {
            korean: {
              type: 'custom',
              tokenizer: 'nori_tokenizer',
              filter: ['nori_readingform', 'lowercase'],
            },
          },
        },
      },
      mappings: {
        properties: {
          name: {
            type: 'text',
            analyzer: 'korean',
            fields: { keyword: { type: 'keyword' } },
          },
          description: { type: 'text', analyzer: 'korean' },
          category: { type: 'keyword' },
          price: { type: 'integer' },
          tags: { type: 'keyword' },
          created_at: { type: 'date' },
        },
      },
    },
  })
}

// 검색
export async function searchProducts(query: string, filters?: {
  category?: string
  minPrice?: number
  maxPrice?: number
  page?: number
  size?: number
}) {
  const must: Record<string, unknown>[] = []
  const filter: Record<string, unknown>[] = []

  if (query) {
    must.push({
      multi_match: {
        query,
        fields: ['name^3', 'description', 'tags^2'],
        type: 'best_fields',
        fuzziness: 'AUTO',
      },
    })
  }

  if (filters?.category) {
    filter.push({ term: { category: filters.category } })
  }

  if (filters?.minPrice || filters?.maxPrice) {
    const range: Record<string, number> = {}
    if (filters.minPrice) range.gte = filters.minPrice
    if (filters.maxPrice) range.lte = filters.maxPrice
    filter.push({ range: { price: range } })
  }

  const result = await esClient.search({
    index: 'products',
    body: {
      query: {
        bool: { must, filter },
      },
      from: ((filters?.page || 1) - 1) * (filters?.size || 20),
      size: filters?.size || 20,
      highlight: {
        fields: { name: {}, description: {} },
      },
    },
  })

  return {
    total: (result.hits.total as { value: number }).value,
    hits: result.hits.hits.map((hit) => ({
      ...hit._source,
      score: hit._score,
      highlights: hit.highlight,
    })),
  }
}

추천 스택:
├── Tailwind CSS ........... 유틸리티 퍼스트 CSS
├── shadcn/ui .............. 복사-붙여넣기 컴포넌트 (소유권)
├── Radix UI ............... 접근성 기반 헤드리스 컴포넌트
├── Framer Motion .......... 애니메이션
└── Lucide Icons ........... 아이콘 세트

대안:
├── Mantine ................ 올인원 UI 라이브러리
├── Ark UI ................. Chakra UI 팀의 헤드리스 컴포넌트
└── Park UI ................ Ark UI + Tailwind

// Zustand 예시 - 간단한 스토어
import { create } from 'zustand'
import { persist } from 'zustand/middleware'

interface CartStore {
  items: Array<{ id: string; name: string; price: number; quantity: number }>
  addItem: (item: { id: string; name: string; price: number }) => void
  removeItem: (id: string) => void
  clearCart: () => void
  total: () => number
}

export const useCartStore = create<CartStore>()(
  persist(
    (set, get) => ({
      items: [],
      addItem: (item) =>
        set((state) => {
          const existing = state.items.find((i) => i.id === item.id)
          if (existing) {
            return {
              items: state.items.map((i) =>
                i.id === item.id ? { ...i, quantity: i.quantity + 1 } : i
              ),
            }
          }
          return { items: [...state.items, { ...item, quantity: 1 }] }
        }),
      removeItem: (id) =>
        set((state) => ({
          items: state.items.filter((i) => i.id !== id),
        })),
      clearCart: () => set({ items: [] }),
      total: () =>
        get().items.reduce((sum, item) => sum + item.price * item.quantity, 0),
    }),
    { name: 'cart-storage' }
  )
)

B2C SaaS → Node.js (TypeScript) + Next.js
├── 풀스택 한 명이 모든 것을 할 수 있음
├── Vercel 배포로 인프라 고민 최소화
└── 프론트엔드-백엔드 타입 공유

B2B SaaS → Node.js or Go
├── API 성능이 중요하면 Go
├── 빠른 기능 개발이 중요하면 Node.js
└── 둘 다 좋은 선택

AI/ML 스타트업 → Python + TypeScript
├── ML 파이프라인은 Python
├── API 서버는 FastAPI (Python) 또는 Next.js (TS)
└── 프론트엔드는 Next.js

핀테크 → Go or Java/Kotlin
├── 높은 성능과 안정성 필요
├── 정적 타입 시스템의 안전성
└── 금융 규제 대응에 강한 생태계

게이밍/리얼타임 → Go or Rust
├── 높은 동시성 처리
├── WebSocket 서버 성능
└── 낮은 지연시간

// src/app/api/v1/products/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { z } from 'zod'
import { createClient } from '@/lib/supabase/server'

// 요청 검증 스키마
const createProductSchema = z.object({
  name: z.string().min(1).max(200),
  description: z.string().max(5000).optional(),
  price: z.number().positive(),
  category: z.string(),
  tags: z.array(z.string()).max(10).optional(),
})

// GET /api/v1/products
export async function GET(req: NextRequest) {
  const searchParams = req.nextUrl.searchParams
  const page = parseInt(searchParams.get('page') || '1')
  const limit = Math.min(parseInt(searchParams.get('limit') || '20'), 100)
  const category = searchParams.get('category')

  const supabase = await createClient()

  let query = supabase
    .from('products')
    .select('*', { count: 'exact' })
    .eq('status', 'active')
    .range((page - 1) * limit, page * limit - 1)
    .order('created_at', { ascending: false })

  if (category) {
    query = query.eq('category', category)
  }

  const { data, count, error } = await query

  if (error) {
    return NextResponse.json({ error: error.message }, { status: 500 })
  }

  return NextResponse.json({
    data,
    pagination: {
      page,
      limit,
      total: count || 0,
      totalPages: Math.ceil((count || 0) / limit),
    },
  })
}

// POST /api/v1/products
export async function POST(req: NextRequest) {
  const supabase = await createClient()
  const { data: { user } } = await supabase.auth.getUser()

  if (!user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  const body = await req.json()
  const parsed = createProductSchema.safeParse(body)

  if (!parsed.success) {
    return NextResponse.json(
      { error: 'Validation failed', details: parsed.error.flatten() },
      { status: 400 }
    )
  }

  const { data, error } = await supabase
    .from('products')
    .insert({ ...parsed.data, user_id: user.id })
    .select()
    .single()

  if (error) {
    return NextResponse.json({ error: error.message }, { status: 500 })
  }

  return NextResponse.json({ data }, { status: 201 })
}

Redis를 도입해야 하는 시점:
├── 동일 쿼리가 초당 100회 이상 실행될 때
├── API 응답 시간이 500ms를 넘길 때
├── 세션 관리가 필요할 때
├── 실시간 기능 (리더보드, 카운터 등)이 필요할 때
├── Rate Limiting이 필요할 때
└── 분산 잠금(Distributed Lock)이 필요할 때

Redis를 아직 도입하지 않아도 되는 시점:
├── DAU 1,000 이하
├── DB 쿼리가 20ms 이내
├── Next.js의 내장 캐시로 충분할 때
└── 비용이 제약이 될 때

Vercel/Railway에서 AWS/GCP로 이동해야 하는 시점:

1. 비용 임계점
   ├── Vercel Pro 비용이 월 500달러를 넘길 때
   ├── 대역폭 비용이 컴퓨팅보다 클 때
   └── 함수 실행 시간 제한에 걸릴 때

2. 기술적 요구사항
   ├── Long-running 프로세스가 필요할 때 (5분+ 이상)
   ├── WebSocket이 핵심 기능일 때
   ├── GPU 컴퓨팅이 필요할 때
   └── 커스텀 네트워크 구성이 필요할 때

3. 규제/컴플라이언스
   ├── 데이터 저장 위치 규제
   ├── SOC 2, HIPAA 등 인증 필요
   └── VPC 격리가 필요할 때

이동하지 않아도 되는 경우:
├── 월 비용 500달러 이하
├── 트래픽이 예측 가능하고 안정적
├── 서버리스 아키텍처로 충분
└── DevOps 전담 인력이 없음

채용이 쉬운 스택 (한국 기준):
├── Next.js + TypeScript (프론트)
├── Node.js + Express/Nest.js (백엔드)
├── PostgreSQL / MySQL (DB)
├── Redis (캐시)
├── Docker + GitHub Actions (DevOps)
└── AWS (인프라)

채용이 어려운 스택:
├── Svelte / SolidJS (프론트)
├── Rust / Elixir (백엔드)
├── CockroachDB / ScyllaDB (DB)
├── Nomad / Consul (오케스트레이션)
└── Pulumi / CDK (IaC)

잘못된 의사결정 패턴:
├── "K8s 경험을 쌓고 싶어서" → K8s 도입 (DAU 100)
├── "Rust가 트렌드라서" → Rust로 API 서버 작성 (팀 2명)
├── "MSA가 정석이라서" → 3명이 10개 서비스 운영
├── "GraphQL이 좋다고 해서" → REST로 충분한 CRUD에 GraphQL
└── "모노레포가 구글에서 쓰니까" → 3명 팀에 Turborepo 셋업

올바른 의사결정:
├── "이 문제를 해결하는 가장 간단한 방법은?"
├── "6개월 뒤에도 유지보수할 수 있는가?"
├── "팀원들이 이미 익숙한 기술인가?"
├── "채용이 용이한 기술인가?"
└── "전환 비용이 감당 가능한가?"

Vercel (Next.js 개발사):
├── Frontend: Next.js (자사 제품)
├── Backend: Go + Node.js
├── Database: PlanetScale (MySQL) → Neon (PostgreSQL)
├── Cache: Redis (Upstash)
├── Search: Turborepo 기반 모노레포
├── Deploy: 자사 플랫폼
├── Monitoring: 자체 구축 + Datadog
└── 특징: 자사 제품을 적극 활용 (dogfooding)

Linear (프로젝트 관리 도구):
├── Frontend: React + TypeScript
├── Backend: Node.js + TypeScript
├── Database: PostgreSQL
├── Cache: Redis
├── Sync: CRDT 기반 실시간 동기화
├── Deploy: Google Cloud
├── Monitoring: 자체 구축
└── 특징: 오프라인 퍼스트, 로컬 데이터 우선

Cal.com (오픈소스 일정 관리):
├── Frontend: Next.js + TypeScript
├── Backend: tRPC + Prisma
├── Database: PostgreSQL
├── Auth: NextAuth.js
├── Email: 다양한 프로바이더 지원
├── Deploy: Vercel
├── Monorepo: Turborepo
└── 특징: 오픈소스, 모노레포, tRPC로 타입 안전