Release Management: From Semantic Versioning to Production Deployment

v1.0.0 - Initial release
v1.0.1 - Fix authentication bug
v1.0.2 - Fix memory leak
v1.1.0 - Add password reset feature
v1.1.1 - Fix password reset email
v1.2.0 - Add OAuth2 support
v1.2.1 - Update dependencies (security)
v2.0.0 - Remove deprecated API v1 endpoints
v2.0.1 - Fix migration script
v2.1.0 - Add GraphQL API
v2.1.0-beta.1 - GraphQL beta testing
v2.1.0-rc.1 - GraphQL release candidate
v2.1.0 - GraphQL stable release

# Tag a new release
git tag -a v2.5.0 -m "Release v2.5.0: Add notification system"
git push origin v2.5.0

# Tag a pre-release
git tag -a v3.0.0-beta.1 -m "Beta release for v3.0.0"
git push origin v3.0.0-beta.1

# List all version tags
git tag -l "v*" | sort -V

Sprint Calendar (6-week cycle):

Week 1-2: Development Sprint
├─ Monday: Sprint planning
├─ Daily: Stand-ups, development
├─ Wednesday: Mid-sprint review
└─ Friday: Demo day

Week 3: Feature Freeze
├─ Monday: Feature freeze begins
├─ Focus: Bug fixes, tests, docs
└─ Friday: Code complete deadline

Week 4: QA Testing
├─ Monday: Deploy to QA
├─ Daily: Test execution
├─ Wednesday: Bug triage
└─ Friday: QA sign-off

Week 5: Release Prep
├─ Monday: Create release branch
├─ Wednesday: Deploy to staging
├─ Thursday: Go/No-Go meeting
└─ Friday: Final prep

Week 6: Production Release
├─ Tuesday 2 AM: Production deployment
├─ Tuesday-Wednesday: Intensive monitoring
└─ Friday: Retrospective, start next cycle

# 1. Create hotfix branch from production tag
git checkout v2.4.5  # Current production version
git checkout -b hotfix/v2.4.6

# 2. Implement fix
# ... make changes ...
git add .
git commit -m "hotfix: Fix null pointer in payment handler"

# 3. Tag hotfix version
git tag -a v2.4.6 -m "Hotfix: Fix payment processing bug"

# 4. Deploy to production
# ... deployment process ...

# 5. Merge back to main branches
git checkout main
git merge hotfix/v2.4.6

git checkout develop
git merge hotfix/v2.4.6

# 6. Push everything
git push origin main develop
git push origin v2.4.6

# 7. Clean up
git branch -d hotfix/v2.4.6

When to use Hotfix Process:

🔴 CRITICAL (Immediate hotfix required):
├─ Production outage (service down)
├─ Data loss or corruption
├─ Security vulnerability (actively exploited)
├─ Revenue-impacting bug (payments failing)
└─ Compliance violation (legal/regulatory)

🟡 HIGH (Expedite in next release):
├─ Performance degradation (slow but working)
├─ Feature partially broken (workaround exists)
├─ Security issue (not actively exploited)
└─ Incorrect data display (non-critical)

🟢 MEDIUM/LOW (Wait for regular release):
├─ Minor UI issues
├─ Documentation errors
├─ Non-critical feature requests
└─ Nice-to-have improvements

# Release Checklist v2.5.0

## Pre-Deploy (T-24 hours)
- [ ] All features code-complete and merged
- [ ] All tests passing (unit, integration, e2e)
- [ ] QA sign-off received
- [ ] Security scan completed (no critical issues)
- [ ] Performance tests passed
- [ ] Release notes written
- [ ] CHANGELOG.md updated
- [ ] Version bumped in package.json / version files
- [ ] Git tag created: v2.5.0
- [ ] Docker images built and pushed
- [ ] Database migration scripts ready
- [ ] Rollback procedures documented
- [ ] Staging environment validated
- [ ] Monitoring dashboards configured
- [ ] Alerting rules updated

## Team Coordination
- [ ] Stakeholders notified (email sent)
- [ ] Maintenance window scheduled
- [ ] On-call engineers confirmed
- [ ] Incident Slack channel ready
- [ ] War room link shared
- [ ] Rollback team identified

## Deploy Phase
- [ ] Backup current production state
- [ ] Snapshot production databases
- [ ] Enable maintenance mode
- [ ] Run database migrations
- [ ] Deploy new application version
- [ ] Update configurations
- [ ] Disable maintenance mode
- [ ] Verify deployment completed

## Verification (First 15 minutes)
- [ ] Health endpoints returning 200 OK
- [ ] All pods/containers running
- [ ] No crash loops detected
- [ ] Smoke tests passing
- [ ] Critical user flows working
- [ ] Error rate < 0.1%
- [ ] Response times normal
- [ ] Database queries performing well
- [ ] External integrations working

## Communication
- [ ] Update status page to "All Systems Operational"
- [ ] Send success notification to team
- [ ] Notify customer success team
- [ ] Update documentation
- [ ] Close release ticket
- [ ] Share release metrics

## Post-Deploy (First 24 hours)
- [ ] Monitor error rates
- [ ] Monitor performance metrics
- [ ] Review user feedback
- [ ] Check support tickets
- [ ] Archive old releases
- [ ] Schedule retrospective

## Sign-Off
- [ ] Engineering Lead: _______________
- [ ] DevOps Lead: _______________
- [ ] Product Manager: _______________
- [ ] QA Lead: _______________

Deployment Time: _______
Duration: _______
Issues: _______

# docker-compose.yml
version: '3.8'

services:
  # API Gateway
  gateway:
    image: kong:3.4
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: postgres
      KONG_PG_USER: kong
      KONG_PG_PASSWORD: kong
      KONG_PROXY_ACCESS_LOG: /dev/stdout
      KONG_ADMIN_ACCESS_LOG: /dev/stdout
      KONG_PROXY_ERROR_LOG: /dev/stderr
      KONG_ADMIN_ERROR_LOG: /dev/stderr
      KONG_ADMIN_LISTEN: 0.0.0.0:8001
    ports:
      - "8000:8000"  # Proxy
      - "8001:8001"  # Admin API
    depends_on:
      - postgres
      - redis

  # User Service
  user-service:
    build: ./services/user-service
    image: myapp/user-service:dev
    environment:
      DATABASE_URL: postgresql://postgres:postgres@postgres:5432/users
      REDIS_URL: redis://redis:6379/0
      JWT_SECRET: dev-secret-key
      LOG_LEVEL: debug
    ports:
      - "3001:3000"
    depends_on:
      - postgres
      - redis
    volumes:
      - ./services/user-service:/app
    command: npm run dev

  # Note Service
  note-service:
    build: ./services/note-service
    image: myapp/note-service:dev
    environment:
      DATABASE_URL: postgresql://postgres:postgres@postgres:5432/notes
      REDIS_URL: redis://redis:6379/1
      USER_SERVICE_URL: http://user-service:3000
      LOG_LEVEL: debug
    ports:
      - "3002:3000"
    depends_on:
      - postgres
      - redis
      - user-service
    volumes:
      - ./services/note-service:/app
    command: npm run dev

  # PostgreSQL Database
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./db/init:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis Cache
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres-data:
  redis-data:

# k8s/production/user-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  namespace: production
  labels:
    app: user-service
    version: v2.5.0
    tier: backend
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
        version: v2.5.0
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9090"
    spec:
      containers:
      - name: user-service
        image: myregistry.com/user-service:v2.5.0
        imagePullPolicy: Always
        ports:
        - containerPort: 3000
          name: http
        - containerPort: 9090
          name: metrics
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: user-service-db-url
        - name: REDIS_URL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: redis-url
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: jwt-secret
              key: secret
        - name: LOG_LEVEL
          value: "info"
        - name: VERSION
          value: "v2.5.0"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 10
          periodSeconds: 5
          timeoutSeconds: 3
          failureThreshold: 2
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
  namespace: production
spec:
  selector:
    app: user-service
  ports:
  - name: http
    port: 80
    targetPort: 3000
  - name: metrics
    port: 9090
    targetPort: 9090
  type: ClusterIP

# db/migrations/config.yml
# Flyway database migration configuration

development:
  url: postgresql://postgres:postgres@localhost:5432/myapp
  user: postgres
  password: postgres
  schemas:
    - users
    - notes
  locations:
    - filesystem:./migrations
  baselineOnMigrate: true

staging:
  url: ${STAGING_DATABASE_URL}
  user: ${DB_USER}
  password: ${DB_PASSWORD}
  schemas:
    - users
    - notes
  locations:
    - filesystem:./migrations
  validateOnMigrate: true
  outOfOrder: false

production:
  url: ${PRODUCTION_DATABASE_URL}
  user: ${DB_USER}
  password: ${DB_PASSWORD}
  schemas:
    - users
    - notes
  locations:
    - filesystem:./migrations
  validateOnMigrate: true
  outOfOrder: false
  # Create backup before migration
  callbacks:
    - BeforeMigrate: scripts/backup-db.sh
    - AfterMigrateError: scripts/rollback-db.sh

#!/bin/bash
# scripts/release.sh
# Automated release management script

set -e

CURRENT_VERSION=$(cat VERSION)
echo "Current version: $CURRENT_VERSION"

# Parse semantic version
IFS='.' read -ra VERSION_PARTS <<< "${CURRENT_VERSION//v/}"
MAJOR=${VERSION_PARTS[0]}
MINOR=${VERSION_PARTS[1]}
PATCH=${VERSION_PARTS[2]}

# Function to bump version
bump_version() {
    local bump_type=$1

    case $bump_type in
        major)
            MAJOR=$((MAJOR + 1))
            MINOR=0
            PATCH=0
            ;;
        minor)
            MINOR=$((MINOR + 1))
            PATCH=0
            ;;
        patch)
            PATCH=$((PATCH + 1))
            ;;
        *)
            echo "Invalid bump type: $bump_type"
            echo "Usage: $0 {major|minor|patch}"
            exit 1
            ;;
    esac

    NEW_VERSION="v${MAJOR}.${MINOR}.${PATCH}"
    echo "New version: $NEW_VERSION"
}

# Update version files
update_version_files() {
    echo "$NEW_VERSION" > VERSION

    # Update package.json
    if [ -f package.json ]; then
        npm version "${NEW_VERSION//v/}" --no-git-tag-version
    fi

    # Update other service package.json files
    find services -name package.json -exec \
        npm --prefix $(dirname {}) version "${NEW_VERSION//v/}" --no-git-tag-version \;
}

# Generate changelog
generate_changelog() {
    echo "Generating changelog..."
    git log "$(git describe --tags --abbrev=0)..HEAD" \
        --pretty=format:"- %s (%h)" >> CHANGELOG.md.tmp

    {
        echo "## $NEW_VERSION ($(date +%Y-%m-%d))"
        echo ""
        cat CHANGELOG.md.tmp
        echo ""
        echo ""
        cat CHANGELOG.md
    } > CHANGELOG.md.new

    mv CHANGELOG.md.new CHANGELOG.md
    rm CHANGELOG.md.tmp
}

# Create git tag
create_git_tag() {
    git add VERSION CHANGELOG.md package.json services/*/package.json
    git commit -m "chore: Bump version to $NEW_VERSION"
    git tag -a "$NEW_VERSION" -m "Release $NEW_VERSION"

    echo "Created tag: $NEW_VERSION"
    echo "Push with: git push origin main --tags"
}

# Build docker images
build_docker_images() {
    echo "Building Docker images..."

    docker build -t myregistry.com/user-service:$NEW_VERSION ./services/user-service
    docker build -t myregistry.com/note-service:$NEW_VERSION ./services/note-service
    docker build -t myregistry.com/gateway:$NEW_VERSION ./services/gateway

    echo "Built images with tag: $NEW_VERSION"
}

# Main execution
main() {
    if [ $# -eq 0 ]; then
        echo "Usage: $0 {major|minor|patch}"
        exit 1
    fi

    bump_version "$1"
    update_version_files
    generate_changelog
    create_git_tag
    build_docker_images

    echo ""
    echo "✅ Release $NEW_VERSION prepared successfully!"
    echo ""
    echo "Next steps:"
    echo "1. Review changes: git show $NEW_VERSION"
    echo "2. Push to remote: git push origin main --tags"
    echo "3. Push images: docker push myregistry.com/user-service:$NEW_VERSION"
    echo "4. Create GitHub release"
    echo "5. Deploy to staging"
}

main "$@"

# config/environments.yaml
# Environment-specific configuration

local:
  services:
    user-service:
      replicas: 1
      resources:
        memory: 256Mi
        cpu: 100m
    note-service:
      replicas: 1
      resources:
        memory: 256Mi
        cpu: 100m
  database:
    host: localhost
    replicas: 1
  redis:
    mode: standalone

dev:
  services:
    user-service:
      replicas: 1
      resources:
        memory: 512Mi
        cpu: 250m
    note-service:
      replicas: 1
      resources:
        memory: 512Mi
        cpu: 250m
  database:
    host: dev-postgres.internal
    replicas: 1
  redis:
    mode: standalone
  domain: dev.api.internal

staging:
  services:
    user-service:
      replicas: 2
      resources:
        memory: 1Gi
        cpu: 500m
    note-service:
      replicas: 2
      resources:
        memory: 1Gi
        cpu: 500m
  database:
    host: staging-postgres.internal
    replicas: 2  # Primary + 1 replica
  redis:
    mode: cluster
    nodes: 3
  domain: staging.api.company.com

production:
  services:
    user-service:
      replicas: 3
      resources:
        memory: 2Gi
        cpu: 1000m
    note-service:
      replicas: 3
      resources:
        memory: 2Gi
        cpu: 1000m
  database:
    host: prod-postgres.internal
    replicas: 3  # Primary + 2 replicas
    backup:
      enabled: true
      schedule: "0 2 * * *"  # Daily at 2 AM
  redis:
    mode: sentinel
    nodes: 3
    sentinels: 3
  domain: api.company.com
  monitoring:
    enabled: true
    retention: 90d

MAJOR.MINOR.PATCH
  ↓      ↓      ↓
  2  .   5  .   0

MAJOR: Breaking changes (v2 → v3)
MINOR: New features, backward compatible (v2.4 → v2.5)
PATCH: Bug fixes, backward compatible (v2.5.0 → v2.5.1)

Microservices:
├─ Hotfixes: As needed (minutes to hours)
├─ Patch releases: Weekly
├─ Minor releases: Bi-weekly or monthly
└─ Major releases: Quarterly or annually

Monoliths:
├─ Hotfixes: As needed
├─ Regular releases: Weekly or bi-weekly
└─ Major releases: Quarterly

main (production)
  ├─ Tag: v2.5.0
  ├─ Tag: v2.4.9
  └─ Tag: v2.4.8

develop (integration)
  ├─ feature/user-auth
  ├─ feature/notifications
  └─ bugfix/login-timeout

hotfix/v2.5.1
  └─ Critical production fix

Deployment Methods:
├─ Blue-Green: Zero-downtime rollback
├─ Canary: Gradual rollout, partial rollback
└─ Rolling: Progressive rollback

Rollback Triggers:
├─ Error rate > 1%
├─ Response time > 2x baseline
├─ Health checks failing
└─ Critical functionality broken

Before Release:
├─ Maintenance window notification (24h advance)
├─ Release notes to stakeholders
└─ Team coordination meeting

During Release:
├─ Real-time updates in Slack
├─ Status page updates
└─ War room for incidents

After Release:
├─ Success notification
├─ Release metrics report
└─ Retrospective meeting