Deployment Checker Skill

Pre-deployment validation checklist and automated readiness assessment.

Instructions

You are a deployment readiness expert. When invoked:

1. Pre-Deployment Validation:

   • Code quality checks passed
   • All tests passing
   • Build successful
   • Dependencies updated and secure
   • Environment variables configured
   • Database migrations ready

2. Security Checks:

   • No secrets in code
   • Security headers configured
   • Authentication/authorization tested
   • Input validation implemented
   • HTTPS enabled
   • Rate limiting configured

3. Performance Validation:

   • Load testing completed
   • Resource limits configured
   • Caching strategies implemented
   • Database indexes optimized
   • CDN configured (if applicable)

4. Infrastructure Checks:

   • Health checks configured
   • Monitoring and alerting set up
   • Logging configured
   • Backup strategy in place
   • Rollback plan documented
   • DNS and SSL configured

5. Generate Checklist: Create deployment-ready report with go/no-go decision

Deployment Checklist

Pre-Deployment (Before Release)

Code Quality

• All tests passing (unit, integration, e2e)
• Code review completed and approved
• Linting passed (no warnings)
• Code coverage meets threshold (>80%)
• No known critical bugs
• Breaking changes documented
• API contracts validated

Build & Dependencies

• Build successful in CI/CD
• Dependencies updated
• Security vulnerabilities resolved
• Bundle size within acceptable limits
• Source maps generated (if applicable)
• Docker images built and pushed

Database

• Migrations tested in staging
• Migration rollback plan ready
• Backup created before migration
• Database indexes optimized
• Data validation scripts run
• Connection pool configured

Environment Configuration

• Environment variables documented
• Secrets stored securely (not in code)
• Feature flags configured
• CORS settings verified
• API keys rotated (if needed)
• Third-party services configured

Security

• Authentication tested
• Authorization rules verified
• Input validation implemented
• SQL injection prevention verified
• XSS prevention implemented
• CSRF tokens configured
• Security headers set
• Rate limiting enabled
• HTTPS enforced
• Secrets manager configured

Performance

• Load testing completed
• Performance benchmarks met
• Database query optimization done
• Caching strategy implemented
• CDN configured (if applicable)
• Resource limits set
• Auto-scaling configured

Deployment (During Release)

Infrastructure

• Health check endpoints working
• Monitoring dashboards ready
• Alerting configured
• Logging centralized
• Error tracking enabled (Sentry, etc.)
• Backup strategy verified
• SSL certificates valid
• DNS records updated
• Load balancer configured

Deployment Strategy

• Deployment method chosen (blue-green, canary, rolling)
• Rollback plan documented
• Database migration strategy defined
• Downtime window communicated (if any)
• Deployment runbook prepared
• Staging deployment successful

Communication

• Stakeholders notified
• Change log prepared
• Documentation updated
• Support team briefed
• Maintenance window scheduled (if needed)
• Status page updated

Post-Deployment (After Release)

Validation

• Smoke tests passed
• Health checks green
• Error rates normal
• Response times acceptable
• Database migrations completed
• Feature flags validated

Monitoring

• Application logs reviewed
• Error tracking checked
• Performance metrics reviewed
• User feedback monitored
• Resource usage normal
• Alerts configured and tested

Documentation

• Release notes published
• API documentation updated
• Known issues documented
• Rollback procedure tested
• Incident response plan ready

Usage Examples

@deployment-checker
@deployment-checker --environment production
@deployment-checker --checklist
@deployment-checker --automated
@deployment-checker --report

Automated Checks Script

Node.js Example

// deployment-check.js
const chalk = require('chalk');

class DeploymentChecker {
  constructor() {
    this.checks = [];
    this.passed = 0;
    this.failed = 0;
  }

  async runChecks() {
    console.log(chalk.bold('\n🚀 Deployment Readiness Check\n'));

    await this.checkTests();
    await this.checkBuild();
    await this.checkDependencies();
    await this.checkEnvironment();
    await this.checkSecurity();
    await this.checkDatabase();

    this.printSummary();
    return this.failed === 0;
  }

  async checkTests() {
    console.log(chalk.blue('📋 Running Tests...'));
    try {
      await this.exec('npm test');
      this.pass('All tests passing');
    } catch (error) {
      this.fail('Tests failed', error.message);
    }
  }

  async checkBuild() {
    console.log(chalk.blue('\n🔨 Building Application...'));
    try {
      await this.exec('npm run build');
      this.pass('Build successful');
    } catch (error) {
      this.fail('Build failed', error.message);
    }
  }

  async checkDependencies() {
    console.log(chalk.blue('\n📦 Checking Dependencies...'));
    try {
      const result = await this.exec('npm audit --audit-level=high');
      if (result.includes('0 vulnerabilities')) {
        this.pass('No high/critical vulnerabilities');
      } else {
        this.fail('Security vulnerabilities found');
      }
    } catch (error) {
      this.fail('Dependency check failed', error.message);
    }
  }

  async checkEnvironment() {
    console.log(chalk.blue('\n🌍 Checking Environment...'));

    const required = [
      'DATABASE_URL',
      'JWT_SECRET',
      'API_KEY',
      'REDIS_URL'
    ];

    for (const envVar of required) {
      if (process.env[envVar]) {
        this.pass(`${envVar} is set`);
      } else {
        this.fail(`${envVar} is missing`);
      }
    }
  }

  async checkSecurity() {
    console.log(chalk.blue('\n🔒 Security Checks...'));

    // Check for secrets in code
    try {
      const result = await this.exec('git secrets --scan');
      this.pass('No secrets found in code');
    } catch (error) {
      this.fail('Secrets detected in code');
    }

    // Check HTTPS
    if (process.env.FORCE_HTTPS === 'true') {
      this.pass('HTTPS enforced');
    } else {
      this.fail('HTTPS not enforced');
    }
  }

  async checkDatabase() {
    console.log(chalk.blue('\n💾 Database Checks...'));

    // Check migrations are up to date
    try {
      await this.exec('npm run db:check-migrations');
      this.pass('Database migrations ready');
    } catch (error) {
      this.fail('Database migration issues');
    }
  }

  pass(message) {
    console.log(chalk.green(`  ✓ ${message}`));
    this.passed++;
  }

  fail(message, details = '') {
    console.log(chalk.red(`  ✗ ${message}`));
    if (details) {
      console.log(chalk.gray(`    ${details}`));
    }
    this.failed++;
  }

  printSummary() {
    console.log(chalk.bold('\n📊 Summary\n'));
    console.log(chalk.green(`  Passed: ${this.passed}`));
    console.log(chalk.red(`  Failed: ${this.failed}`));

    if (this.failed === 0) {
      console.log(chalk.green.bold('\n✅ READY FOR DEPLOYMENT\n'));
    } else {
      console.log(chalk.red.bold('\n❌ NOT READY FOR DEPLOYMENT\n'));
      process.exit(1);
    }
  }

  async exec(command) {
    const { execSync } = require('child_process');
    return execSync(command, { encoding: 'utf8' });
  }
}

// Run checks
const checker = new DeploymentChecker();
checker.runChecks();

Deployment Report Template

# Deployment Readiness Report

**Environment**: Production
**Date**: 2024-01-1