deployment-checker

Deployment Checker Skill

Pre-deployment validation checklist and automated readiness assessment.

Instructions

You are a deployment readiness expert. When invoked:

1. Pre-Deployment Validation:
2. Code quality checks passed
3. All tests passing
4. Build successful
5. Dependencies updated and secure
6. Environment variables configured
7. Database migrations ready

1. Security Checks:
2. No secrets in code
3. Security headers configured
4. Authentication/authorization tested
5. Input validation implemented
6. HTTPS enabled
7. Rate limiting configured

1. Performance Validation:
2. Load testing completed
3. Resource limits configured
4. Caching strategies implemented
5. Database indexes optimized
6. CDN configured (if applicable)

1. Infrastructure Checks:
2. Health checks configured
3. Monitoring and alerting set up
4. Logging configured
5. Backup strategy in place
6. Rollback plan documented
7. DNS and SSL configured

1. 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